# GraphQL API Authentication
Source: https://docs.sensorup.com/api/graphql/authentication
Learn how to authenticate with the SensorUp GraphQL API using sessions, API keys, and AWS credentials.
# Authentication
The SensorUp GraphQL API supports multiple authentication methods depending on your use case and environment.
## Authentication Methods
| Method | Use Case | Lifetime | MFA Support |
| - | - | - | - |
| **Session-based** | Interactive web applications | 7-30 days idle, 30-365 days max (varies by client) | Yes |
| **API Keys** | Machine-to-machine, integrations | 60 days idle, 365 days max | No |
| **Federated Sign-in** | SSO integration | Same as session-based | Via SSO provider |
All authentication methods use the same session ID mechanism - either via the `sensorup_sessionid` cookie (browser) or `x-sensorup-sessionid` header (API clients).
## Session-Based Authentication
Session-based authentication is the primary method for interactive applications where users log in with username and password.
### Sign In
```graphql theme={null}
mutation SignIn($input: AuthSignInInput!) {
signIn(input: $input) {
session {
username
authenticated
expiresAt
expiresAtHard
userGroup
challengeName
}
correlationId
errors {
message
type
}
}
}
```
**Variables:**
```json theme={null}
{
"input": {
"loginUsername": "user@example.com",
"password": "your-password",
"clientApplicationType": "EXPLORER"
}
}
```
### Session Response
```json theme={null}
{
"data": {
"signIn": {
"session": {
"username": "user@example.com",
"authenticated": true,
"expiresAt": "2025-11-05T18:00:00Z",
"expiresAtHard": "2025-11-06T10:00:00Z",
"userGroup": "your-tenant-id",
"challengeName": null
},
"correlationId": "abc-123",
"errors": []
}
}
}
```
### Checking Current Session
```graphql theme={null}
query GetSession {
session {
username
authenticated
expiresAt
userGroup
lastAuthenticatedAt
}
}
```
### Sign Out
```graphql theme={null}
mutation SignOut {
signOut {
session {
authenticated
}
correlationId
errors {
message
type
}
}
}
```
### Using Your Session
After successful sign-in, your session ID is used to authenticate subsequent API requests. There are two methods:
#### 1. Cookie Authentication (Browser/Web)
When you sign in through a web browser, the `sensorup_sessionid` cookie is automatically set and sent with each request:
```
Cookie: sensorup_sessionid=YOUR_SESSION_ID
```
This happens automatically - you don't need to manually set this cookie in browser applications.
#### 2. Header Authentication (Machine-to-Machine)
For API clients, mobile apps, and integrations, pass the session ID in the `x-sensorup-sessionid` header:
```bash theme={null}
curl -X POST https://customer-demo.sensorup.com/api/graphql \
-H "Content-Type: application/json" \
-H "x-sensorup-sessionid: YOUR_SESSION_ID" \
-d '{"query":"{ session { username authenticated } }"}'
```
**Using with HTTP clients:**
```javascript theme={null}
// JavaScript/Node.js
fetch('https://customer-demo.sensorup.com/api/graphql', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
'x-sensorup-sessionid': sessionId
},
body: JSON.stringify({ query: '{ session { username } }' })
})
```
```python theme={null}
# Python
import requests
response = requests.post(
'https://customer-demo.sensorup.com/api/graphql',
headers={
'Content-Type': 'application/json',
'x-sensorup-sessionid': session_id
},
json={'query': '{ session { username } }'}
)
```
## Multi-Factor Authentication (MFA)
When MFA is required, the sign-in mutation returns a `challengeName`:
### MFA Challenge Response
```json theme={null}
{
"session": {
"username": "user@example.com",
"authenticated": false,
"challengeName": "SMS_MFA",
"challengeParam": {}
}
}
```
### Challenge Types
| Challenge | Description |
| - | - |
| `SMS_MFA` | SMS-based one-time code |
| `SOFTWARE_TOKEN_MFA` | TOTP authenticator app |
| `MFA_SETUP` | MFA setup required |
| `NEW_PASSWORD_REQUIRED` | Password reset required |
### Completing MFA Challenge
```graphql theme={null}
mutation ConfirmSignIn($input: AuthConfirmSignInInput!) {
confirmSignIn(input: $input) {
session {
username
authenticated
expiresAt
}
correlationId
errors {
message
type
}
}
}
```
**Variables:**
```json theme={null}
{
"input": {
"code": "123456",
"mfaType": "SMS_MFA"
}
}
```
## API Key Authentication
API keys are designed for machine-to-machine communication and integration scenarios. API keys generate sessions just like user logins, but with longer lifetimes.
### Creating an API Key
```graphql theme={null}
mutation CreateAPIKey($input: AuthCreateAPIKeyInput!) {
createAPIKey(input: $input) {
apiKey {
apiKeyId
apiKeySessionId
username
authenticated
expiresAt
userGroup
}
correlationId
errors {
message
type
}
}
}
```
**Variables:**
```json theme={null}
{
"input": {
"apiKeyId": "my-integration-key",
"userGroup": "your-tenant-id"
}
}
```
The response includes an `apiKeySessionId` which is the session ID you'll use for authentication.
API keys provide full access to the API with the same permissions as the user who created them. Store them securely and rotate them regularly.
### Using API Keys
Use the API key session ID in the `x-sensorup-sessionid` header (same as regular sessions):
```bash theme={null}
curl -X POST https://customer-demo.sensorup.com/api/graphql \
-H "Content-Type: application/json" \
-H "x-sensorup-sessionid: YOUR_API_KEY_SESSION_ID" \
-d '{"query":"{ session { username } }"}'
```
**Integration Example:**
```javascript theme={null}
// Store the API key session ID securely
const apiKeySessionId = process.env.SENSORUP_API_KEY_SESSION_ID
// Use in requests
const response = await fetch('https://customer-demo.sensorup.com/api/graphql', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
'x-sensorup-sessionid': apiKeySessionId
},
body: JSON.stringify({ query: '{ session { username } }' })
})
```
## AWS Credentials
For accessing AWS services (S3, etc.), you can obtain temporary AWS credentials:
### Getting AWS Credentials
```graphql theme={null}
query GetCredentials($group: String) {
credentials(group: $group) {
accessKeyId
secretAccessKey
sessionToken
expiration
}
}
```
**Response:**
```json theme={null}
{
"data": {
"credentials": {
"accessKeyId": "ASIA...",
"secretAccessKey": "...",
"sessionToken": "...",
"expiration": "2025-11-05T18:00:00Z"
}
}
}
```
### Using AWS Credentials
```javascript theme={null}
import AWS from 'aws-sdk'
// Configure AWS SDK with credentials from GraphQL
AWS.config.credentials = new AWS.Credentials({
accessKeyId: credentials.accessKeyId,
secretAccessKey: credentials.secretAccessKey,
sessionToken: credentials.sessionToken
})
// Use AWS services
const s3 = new AWS.S3()
```
## Federated Sign-In (SSO)
For organizations using SSO, you can authenticate with Cognito tokens:
```graphql theme={null}
mutation FederatedSignIn($input: AuthFederatedSignInInput!) {
federatedSignIn(input: $input) {
session {
username
authenticated
expiresAt
userGroup
}
correlationId
errors {
message
type
}
}
}
```
**Variables:**
```json theme={null}
{
"input": {
"cognitoIdToken": "your-id-token",
"clientApplicationType": "EXPLORER"
}
}
```
SSO configuration is tenant-specific. Contact your SensorUp account team for SSO setup and configuration.
## Session Management
### Session Expiration
Sessions have two expiration times:
* **Soft Expiry (Idle Timeout)**: Session extends with activity up to this limit
* **Hard Expiry (Maximum Lifetime)**: Absolute maximum session duration - requires re-authentication after this time
Session lifetimes vary by client application type:
| Client Application Type | Hard Expiry (Max Lifetime) | Soft Expiry (Idle Timeout) |
| - | - | - |
| **Explorer** (Web) | 30 days | 7 days |
| **SensorHub Android** | 365 days | 60 days |
| **SensorHub iOS** | 365 days | 60 days |
| **API Key** | 365 days | 60 days |
**How it works:**
* If you're actively using the API, your session stays valid until the hard expiry time
* If you're inactive for longer than the soft expiry (idle timeout), the session expires
* After hard expiry, you must sign in again regardless of activity
* The `expiresAt` field in the session response reflects the current soft expiry time
* The `expiresAtHard` field shows the absolute maximum session lifetime
### Switching User Groups
If your user has access to multiple tenant groups:
```graphql theme={null}
mutation SetUserGroup($input: AuthSetSessionUserGroupInput!) {
setSessionUserGroup(input: $input) {
session {
userGroup
}
correlationId
errors {
message
type
}
}
}
```
**Variables:**
```json theme={null}
{
"input": {
"userGroup": "different-tenant-id"
}
}
```
### Re-authentication
For sensitive operations, you may need to re-authenticate:
```graphql theme={null}
mutation Reauthenticate($input: ReauthenticationInput!) {
reauthenticate(input: $input) {
session {
username
authenticated
lastAuthenticatedAt
}
correlationId
errors {
message
type
}
}
}
```
**Variables:**
```json theme={null}
{
"input": {
"password": "your-password"
}
}
```
## Device Management
Track and manage authenticated devices:
### Listing Devices
```graphql theme={null}
query GetUserDevices($userId: ID!) {
user(id: $userId) {
devices {
deviceKey
name
remembered
createdAt
lastSignedInAt
lastIpAddress
}
}
}
```
### Forgetting Devices
```graphql theme={null}
mutation ForgetDevices($input: AuthForgetSpecificDevicesInput!) {
forgetDevices(input: $input) {
session {
username
}
correlationId
errors {
message
type
}
}
}
```
**Variables:**
```json theme={null}
{
"input": {
"deviceKeys": ["device-key-1", "device-key-2"]
}
}
```
## Password Management
### Forgot Password
```graphql theme={null}
mutation ForgotPassword($input: AuthForgotPasswordInput!) {
forgotPassword(input: $input) {
correlationId
errors {
message
type
}
}
}
```
**Variables:**
```json theme={null}
{
"input": {
"loginUsername": "user@example.com"
}
}
```
### Reset Password
```graphql theme={null}
mutation ForgotPasswordSubmit($input: AuthForgotPasswordSubmitInput!) {
forgotPasswordSubmit(input: $input) {
session {
username
authenticated
}
correlationId
errors {
message
type
}
}
}
```
**Variables:**
```json theme={null}
{
"input": {
"loginUsername": "user@example.com",
"confirmationCode": "123456",
"password": "new-password"
}
}
```
## Authentication Configuration
Query authentication configuration for your environment:
```graphql theme={null}
query GetAuthConfig {
config {
auth {
loginEnabled
ssoEnabled
ssoUrl
}
}
}
```
## Best Practices
1. **Use sessions for interactive applications**: Session-based auth with MFA provides the best security for user-facing applications
2. **Use API keys for integrations**: Machine-to-machine communication should use API keys with appropriate scoping
3. **Rotate credentials regularly**: Implement key rotation policies for long-lived API keys
4. **Handle session expiration gracefully**: Check `expiresAt` and refresh or re-authenticate before expiration
5. **Store credentials securely**: Never commit credentials to version control; use environment variables or secret management systems
6. **Monitor authentication events**: Track authentication failures and unusual patterns
## Next Steps
* **[Quickstart Guide](./quickstart)** - Make your first authenticated query
* **[Common Patterns](./common-patterns)** - Learn about pagination and filtering
* **[Domain Guides](./guides/cam-assets)** - Explore specific API capabilities
# Common Patterns
Source: https://docs.sensorup.com/api/graphql/common-patterns
Essential patterns for working with the SensorUp GraphQL API - pagination, filtering, error handling, and GeoJSON.
# Common Patterns
This guide covers common patterns you'll use throughout the SensorUp GraphQL API.
## Pagination
The API uses **Relay-style cursor-based pagination** for all list queries. This provides consistent forward and backward pagination with cursor stability.
### Connection Structure
```graphql theme={null}
type Connection {
edges: [Edge]
pageInfo: PageInfo!
}
type Edge {
node: NodeType
cursor: String
}
type PageInfo {
hasNextPage: Boolean!
hasPreviousPage: Boolean!
startCursor: String
endCursor: String
}
```
### Forward Pagination
```graphql theme={null}
query GetAssets($first: Int!, $after: String) {
assetProfiles {
byId(profile: "your-profile") {
assets(first: $first, after: $after) {
edges {
node {
id
displayName
}
cursor
}
pageInfo {
hasNextPage
endCursor
}
}
}
}
}
```
**First page:**
```json theme={null}
{
"first": 20
}
```
**Next page:**
```json theme={null}
{
"first": 20,
"after": "cursor-from-endCursor"
}
```
### Backward Pagination
```graphql theme={null}
query GetAssets($last: Int!, $before: String) {
assetProfiles {
byId(profile: "your-profile") {
assets(last: $last, before: $before) {
edges {
node {
id
displayName
}
}
pageInfo {
hasPreviousPage
startCursor
}
}
}
}
}
```
### Pagination Best Practices
1. **Use reasonable page sizes**: 10-100 items per page depending on data size
2. **Store cursors, not offsets**: Cursors remain valid even when data changes
3. **Check hasNextPage**: Don't assume there's always a next page
4. **Handle missing cursors**: Some connections may not return cursors for every edge
## Filtering
Most list queries support filtering through typed input objects.
### Time-Based Filtering
```graphql theme={null}
query GetRecentAssets($filter: AssetFilter!) {
assetProfiles {
byId(profile: "your-profile") {
assets(first: 20, filter: $filter) {
edges {
node {
id
displayName
modifiedAt
}
}
}
}
}
}
```
**Variables:**
```json theme={null}
{
"filter": {
"modifiedAfter": "2025-11-01T00:00:00Z"
}
}
```
### Property-Based Filtering
Some queries allow filtering by specific properties:
```graphql theme={null}
query FilteredObservations(
$startTime: DateTime,
$endTime: DateTime,
$properties: [String!]
) {
assetProfiles {
byId(profile: "your-profile") {
upQueryObservations(
startTime: $startTime,
endTime: $endTime,
properties: $properties
)
}
}
}
```
**Variables:**
```json theme={null}
{
"startTime": "2025-11-01T00:00:00Z",
"endTime": "2025-11-05T00:00:00Z",
"properties": ["temperature", "pressure"]
}
```
## Error Handling
The API uses two error patterns: GraphQL-level errors and mutation-level errors.
### GraphQL Errors
GraphQL errors appear in the `errors` array at the top level:
```json theme={null}
{
"errors": [
{
"message": "Cannot query field 'invalidField' on type 'Asset'",
"locations": [{ "line": 3, "column": 5 }],
"path": ["assetProfiles", "byId", "invalidField"]
}
],
"data": null
}
```
**Common GraphQL error types:**
* **Validation errors**: Invalid query syntax or schema violations
* **Authentication errors**: Missing or invalid credentials
* **Authorization errors**: Insufficient permissions
* **Internal errors**: Server-side issues
### Mutation Errors
Mutations return errors in their result type using the `MutationError` interface:
```graphql theme={null}
interface MutationError {
message: String!
type: String!
}
```
**Example mutation with errors:**
```graphql theme={null}
mutation CreateAssetFilter($input: CreateAssetFilterInput!) {
createAssetFilter(input: $input) {
assetFilter {
id
displayName
}
correlationId
errors {
message
type
}
}
}
```
**Response with validation error:**
```json theme={null}
{
"data": {
"createAssetFilter": {
"assetFilter": null,
"correlationId": "abc-123",
"errors": [
{
"message": "Display name is required",
"type": "VALIDATION_ERROR"
}
]
}
}
}
```
### Error Handling Pattern
```javascript theme={null}
const result = await executeQuery(mutation, variables)
// Check for GraphQL-level errors
if (result.errors) {
console.error('GraphQL errors:', result.errors)
return
}
// Check for mutation-level errors
const { assetFilter, errors } = result.data.createAssetFilter
if (errors && errors.length > 0) {
console.error('Mutation errors:', errors)
return
}
// Success
console.log('Created asset filter:', assetFilter)
```
## GeoJSON Support
The API has comprehensive GeoJSON support for geospatial data.
### GeoJSON Types
```graphql theme={null}
enum GeoJSONType {
Point
MultiPoint
LineString
MultiLineString
Polygon
MultiPolygon
GeometryCollection
Feature
FeatureCollection
}
```
### Querying Geometry
```graphql theme={null}
query GetAssetGeometry($profileId: ID!, $assetId: ID!) {
assetProfiles {
byId(profile: $profileId) {
assetById(id: $assetId) {
id
displayName
geometry {
type
coordinates
bbox
}
geoJSONFeature
}
}
}
}
```
**Response:**
```json theme={null}
{
"data": {
"assetProfiles": {
"byId": {
"assetById": {
"id": "asset-123",
"displayName": "Well Site A",
"geometry": {
"type": "Point",
"coordinates": [-114.0719, 51.0447],
"bbox": null
},
"geoJSONFeature": {
"type": "Feature",
"geometry": {
"type": "Point",
"coordinates": [-114.0719, 51.0447]
},
"properties": {
"name": "Well Site A"
},
"id": "asset-123"
}
}
}
}
}
}
```
### GeoJSON Input
```graphql theme={null}
input GeoJSONGeometryInput {
type: GeoJSONType!
coordinates: GeoJSONCoordinates
bbox: [Float]
}
```
**Example usage in mutations:**
```json theme={null}
{
"geometry": {
"type": "Point",
"coordinates": [-114.0719, 51.0447]
}
}
```
### Coordinate Systems
* All coordinates use **WGS84** (EPSG:4326)
* Coordinate order: `[longitude, latitude]` (GeoJSON standard)
* Elevations can be included as third coordinate: `[lon, lat, elevation]`
## Audit Trails
Many types include audit information for tracking changes.
### Audit Type
```graphql theme={null}
type Audit {
createdTime: DateTime!
updatedTime: DateTime!
createdBy: UserReference
updatedBy: UserReference
}
```
### Querying Audit Information
```graphql theme={null}
query GetIssueAudit($issueId: ID!) {
issues {
byId(id: $issueId) {
id
displayName
audit {
createdTime
updatedTime
createdBy {
userId
}
updatedBy {
userId
}
}
}
}
}
```
**Response:**
```json theme={null}
{
"data": {
"issues": {
"byId": {
"id": "issue-123",
"displayName": "Equipment Failure",
"audit": {
"createdTime": "2025-11-01T10:00:00Z",
"updatedTime": "2025-11-03T14:30:00Z",
"createdBy": {
"userId": "user-1"
},
"updatedBy": {
"userId": "user-2"
}
}
}
}
}
}
```
## Entity References
Apollo Federation enables cross-subgraph entity resolution.
### User References
```graphql theme={null}
type UserReference @key(fields: "userId") {
userId: ID!
}
```
**Query user references:**
```graphql theme={null}
query GetUserDetails {
issues {
byId(id: "issue-123") {
audit {
createdBy {
userId
# Additional user fields resolved by su-user subgraph
}
}
}
}
}
```
### Asset References
```graphql theme={null}
type AssetReference @key(fields: "profile assetId") {
profile: ID
assetId: ID!
asset: Asset
}
```
## DateTime Handling
All timestamps use ISO-8601 format in UTC.
### DateTime Format
```
2025-11-05T14:30:00Z
2025-11-05T14:30:00.123Z (with milliseconds)
```
### Querying with DateTime
```graphql theme={null}
query GetRecentData($startTime: DateTime!, $endTime: DateTime!) {
assetProfiles {
byId(profile: "your-profile") {
upQueryObservations(
startTime: $startTime,
endTime: $endTime
)
}
}
}
```
**Variables:**
```json theme={null}
{
"startTime": "2025-11-01T00:00:00Z",
"endTime": "2025-11-05T23:59:59Z"
}
```
### Relative Time Queries
Some fields support relative time strings:
```graphql theme={null}
query GetLiveData {
assetProfiles {
byId(profile: "your-profile") {
# Historical: "7 days ago" to "now"
upQuery(startTime: "7 days ago", endTime: "now")
# Live data: "now"
upQuery(startTime: "now")
}
}
}
```
## JSONObject Type
The `JSONObject` scalar represents arbitrary JSON data.
### Querying JSON Properties
```graphql theme={null}
query GetAssetProperties($profileId: ID!, $assetId: ID!) {
assetProfiles {
byId(profile: $profileId) {
assetById(id: $assetId) {
id
properties
observation
}
}
}
}
```
**Response:**
```json theme={null}
{
"data": {
"assetProfiles": {
"byId": {
"assetById": {
"id": "asset-123",
"properties": {
"name": "Well Site A",
"operator": "Company XYZ",
"capacity": 1000
},
"observation": {
"phenomenonTime": "2025-11-05T14:00:00Z",
"result": {
"pressure": 150.5,
"temperature": 22.3
}
}
}
}
}
}
}
```
### Filtering JSON Properties
```graphql theme={null}
query GetSelectedProperties(
$profileId: ID!,
$assetId: ID!,
$properties: [String!]
) {
assetProfiles {
byId(profile: $profileId) {
assetById(id: $assetId) {
id
properties(only: $properties)
}
}
}
}
```
**Variables:**
```json theme={null}
{
"profileId": "wells",
"assetId": "well-123",
"properties": ["name", "operator"]
}
```
## Correlation IDs
All mutations return a `correlationId` for tracking and debugging.
```graphql theme={null}
mutation CreateAssetFilter($input: CreateAssetFilterInput!, $correlationId: String) {
createAssetFilter(input: $input, correlationId: $correlationId) {
assetFilter {
id
}
correlationId
errors {
message
}
}
}
```
**Providing your own correlation ID:**
```json theme={null}
{
"input": { ... },
"correlationId": "my-unique-id-123"
}
```
Use correlation IDs for:
* Request tracking across systems
* Debugging with support teams
* Audit logging
* Idempotency (some mutations)
## Best Practices
1. **Request only needed fields**: GraphQL allows precise field selection - use it to reduce payload size
2. **Use fragments for reusability**: Define reusable fragments for common field sets
3. **Batch related queries**: Use GraphQL's ability to query multiple resources in one request
4. **Handle errors at both levels**: Check for GraphQL errors AND mutation errors
5. **Store cursors for pagination**: Cursors remain stable across data changes
6. **Use correlation IDs**: Include them for better debugging and tracking
7. **Respect rate limits**: Implement exponential backoff for retries
8. **Cache appropriately**: Consider caching strategies based on data volatility
## Next Steps
* **[Domain Guides](./guides/cam-assets)** - Explore specific use cases
* **[Subgraph Reference](./subgraphs/assets)** - Detailed schema documentation
* **[Federation Concepts](./federation)** - Understanding entity composition
* **[Performance](./performance)** - Optimization and best practices
# Apollo Federation Concepts
Source: https://docs.sensorup.com/api/graphql/federation
Understanding how the SensorUp GraphQL API uses Apollo Federation to compose multiple subgraphs into a unified API.
# Apollo Federation Concepts
The SensorUp GraphQL API is built on **Apollo Federation v2.3**, which enables multiple independent GraphQL services (subgraphs) to be composed into a single, unified graph.
## What is Apollo Federation?
Apollo Federation is an architecture for building distributed GraphQL APIs. Instead of one monolithic GraphQL server, Federation allows you to:
* **Separate concerns**: Each subgraph owns a specific domain
* **Scale independently**: Subgraphs can be deployed and scaled separately
* **Compose seamlessly**: The gateway stitches subgraphs into one unified API
* **Extend types**: Subgraphs can add fields to types defined elsewhere
## Architecture Overview
```mermaid theme={null}
graph TD
Gateway[GraphQL Gateway
Apollo Router]
Gateway --> Assets[su-assets
Asset Profiles]
Gateway --> Auth[su-auth
Authentication]
Gateway --> CAM[su-cam-assets
Connected Assets]
Gateway --> Issues[su-issues
Issue Tracking]
Gateway --> LDAR[su-methane-ldar-backend
LDAR Operations]
Gateway --> Workflow[su-workflow
Workflows]
Gateway --> Forms[su-forms
XForms]
Gateway --> Maps[su-maps
Geospatial]
Gateway --> More[... 7 more subgraphs]
style Gateway fill:#4A90E2,stroke:#2E5C8A,stroke-width:3px,color:#fff
style Assets fill:#7B68EE,stroke:#5A4CB8,color:#fff
style Auth fill:#7B68EE,stroke:#5A4CB8,color:#fff
style CAM fill:#7B68EE,stroke:#5A4CB8,color:#fff
style Issues fill:#7B68EE,stroke:#5A4CB8,color:#fff
style LDAR fill:#7B68EE,stroke:#5A4CB8,color:#fff
style Workflow fill:#7B68EE,stroke:#5A4CB8,color:#fff
style Forms fill:#7B68EE,stroke:#5A4CB8,color:#fff
style Maps fill:#7B68EE,stroke:#5A4CB8,color:#fff
style More fill:#9B9B9B,stroke:#6B6B6B,color:#fff
```
When you query the gateway:
1. Gateway receives your GraphQL query
2. Creates a query plan across relevant subgraphs
3. Executes queries against subgraphs (in parallel where possible)
4. Stitches results together
5. Returns unified response
## Key Federation Concepts
### Entities
Entities are types that can be referenced and extended across subgraphs. They're marked with the `@key` directive.
```graphql theme={null}
type Asset @key(fields: "profile id") {
profile: ID!
id: ID!
displayName: String!
}
```
The `@key` directive specifies the fields needed to uniquely identify an instance of this type.
### Type Extensions
Subgraphs can extend types defined in other subgraphs using `@extends`:
```graphql theme={null}
type Asset @key(fields: "profile id") @extends {
profile: ID! @external
id: ID! @external
issueSubject: IssueSubject! # Added by su-issues subgraph
}
```
This allows the `su-issues` subgraph to add the `issueSubject` field to the `Asset` type originally defined in `su-assets`.
### Entity Resolution
When a subgraph needs to resolve an entity, it provides a reference resolver:
```javascript theme={null}
// In su-issues subgraph
{
Asset: {
__resolveReference(reference) {
// reference = { profile: "wells", id: "well-123" }
// Return asset-specific issue information
return {
profile: reference.profile,
id: reference.id,
issueSubject: getIssueSubjectForAsset(reference)
}
}
}
}
```
## SensorUp Federation Structure
### Entity Ownership
| Entity | Owner | Extended By |
| - | - | - |
| `Asset` | su-assets | su-issues, su-eventhub |
| `User` | su-user | su-auth |
| `Site` | su-sites | su-methane-ldar-backend |
| `Issue` | su-issues | (none) |
| `EmissionObservation` | su-methane-ldar-backend | (none) |
### Shared Types
Some types are marked `@shareable`, meaning multiple subgraphs can define them:
```graphql theme={null}
type PageInfo @shareable {
hasNextPage: Boolean!
hasPreviousPage: Boolean!
startCursor: String
endCursor: String
}
```
Common shareable types:
* `PageInfo` - Pagination metadata
* `GeoJSON*` types - Geospatial types
* Scalar types - `DateTime`, `JSONObject`
## Cross-Subgraph Queries
Federation enables queries that span multiple subgraphs seamlessly.
### Example: Asset with Issue Information
```graphql theme={null}
query GetAssetWithIssues($profile: ID!, $assetId: ID!) {
assetProfiles { # su-assets subgraph
byId(profile: $profile) {
assetById(id: $assetId) {
id
displayName # su-assets
properties # su-assets
issueSubject { # su-issues extends Asset
type
reference
issues { # su-issues
id
title
status
}
}
}
}
}
}
```
The gateway:
1. Queries `su-assets` for asset data
2. Takes the asset reference
3. Queries `su-issues` for issue information
4. Merges the results
### Example: User with Authentication
```graphql theme={null}
query GetUserDetails($userId: ID!) {
user(id: $userId) { # su-user subgraph
id
name # su-user
email # su-user
devices { # su-auth extends User
deviceKey # su-auth
name # su-auth
lastSignedInAt # su-auth
}
}
}
```
## Federation Directives
### @key
Marks a type as an entity with a unique key:
```graphql theme={null}
type Asset @key(fields: "profile id") {
profile: ID!
id: ID!
# ...
}
```
Multiple keys are supported:
```graphql theme={null}
type Asset
@key(fields: "profile id")
@key(fields: "catalogId dataset assetId") {
# ...
}
```
### @extends
Indicates a type is being extended from another subgraph:
```graphql theme={null}
type Asset @key(fields: "profile id") @extends {
profile: ID! @external
id: ID! @external
newField: String!
}
```
### @external
Marks fields that are defined in another subgraph:
```graphql theme={null}
type Asset @key(fields: "profile id") @extends {
profile: ID! @external
id: ID! @external
computedField: String! @requires(fields: "profile id")
}
```
### @requires
Specifies fields needed from the base type to resolve a field:
```graphql theme={null}
type Asset @key(fields: "profile id") @extends {
profile: ID! @external
displayName: String! @external
enrichedName: String! @requires(fields: "displayName")
}
```
### @provides
Optimizes queries by providing fields from related entities:
```graphql theme={null}
type AssetProfile @key(fields: "profile") {
upSpecification: UpSpecification @provides(fields: "catalogId dataset")
}
```
### @shareable
Allows multiple subgraphs to define the same type/field:
```graphql theme={null}
type PageInfo @shareable {
hasNextPage: Boolean!
hasPreviousPage: Boolean!
}
```
## Query Planning
The gateway creates an optimized query plan for each request.
### Simple Query
```graphql theme={null}
query {
session {
username
authenticated
}
}
```
Query plan:
```
QueryPlan {
Fetch(service: "su-auth") {
{ session { username authenticated } }
}
}
```
### Cross-Subgraph Query
```graphql theme={null}
query {
assetProfiles {
byId(profile: "wells") {
assets(first: 10) {
edges {
node {
id
displayName # su-assets
issueSubject { # su-issues
issues {
id
title
}
}
}
}
}
}
}
}
```
Query plan:
```
QueryPlan {
Sequence {
Fetch(service: "su-assets") {
{ assetProfiles { byId(profile: "wells") {
assets(first: 10) {
edges {
node { __typename profile id displayName }
}
}
}
}}
},
Flatten(path: "assetProfiles.byId.assets.edges.@.node") {
Fetch(service: "su-issues") {
{ ... on Asset { __typename profile id issueSubject {
issues { id title }
}
}}
}
}
}
}
```
## Performance Considerations
### Parallel Execution
Federation executes independent fetches in parallel:
```graphql theme={null}
query {
session { # su-auth - fetched in parallel
username
}
assetProfiles { # su-assets - fetched in parallel
all(first: 10) {
edges {
node {
title
}
}
}
}
}
```
### N+1 Problem
Be aware of the N+1 problem with entity references:
```graphql theme={null}
query {
issues {
all(first: 100) {
edges {
node {
id
subject {
assetReference {
asset { # Potentially 100 lookups to su-assets!
displayName
}
}
}
}
}
}
}
}
```
**Solution**: Federation batches entity resolutions using DataLoader-like mechanisms.
## Debugging Federation
### Query Plan Visualization
Use Apollo Studio to visualize query plans and identify performance bottlenecks.
### Subgraph Errors
When a subgraph fails, the error includes the service name:
```json theme={null}
{
"errors": [
{
"message": "Failed to fetch from subgraph 'su-assets'",
"extensions": {
"serviceName": "su-assets",
"code": "SUBREQUEST_HTTP_ERROR"
}
}
]
}
```
### Trace Subgraph Calls
Monitor subgraph execution times:
```json theme={null}
{
"extensions": {
"ftv1": "base64-encoded-trace-data"
}
}
```
## Best Practices
1. **Design entity keys carefully**: Choose stable, immutable fields for `@key`
2. **Minimize entity hops**: Deeply nested cross-subgraph queries can be slow
3. **Use @provides sparingly**: Only when it significantly reduces fetches
4. **Batch related queries**: Combine multiple operations in one request
5. **Monitor query plans**: Use Apollo Studio to identify inefficient plans
6. **Handle partial failures**: Subgraph failures may return partial data
7. **Version subgraph changes**: Coordinate breaking changes across subgraphs
8. **Test entity resolution**: Ensure reference resolvers handle all key combinations
## Differences from Schema Stitching
| Feature | Federation | Schema Stitching |
| - | - | - |
| Type ownership | Clear owner per type | Ambiguous |
| Type extension | Native support | Manual |
| Query planning | Automatic | Manual |
| Performance | Optimized | Variable |
| DX | Better | Complex |
## Resources
* **[Apollo Federation Documentation](https://www.apollographql.com/docs/federation/)**
* **[Subgraph Reference](./subgraphs/assets)** - SensorUp subgraph schemas
* **[Performance Guide](./performance)** - Optimization strategies
## Studio Access
For detailed query planning and performance monitoring, access Apollo Studio:
[https://studio.apollographql.com/graph/su-graphql-t912yf/](https://studio.apollographql.com/graph/su-graphql-t912yf/)
(Contact your SensorUp account team for access)
# Connected Asset Management Guide
Source: https://docs.sensorup.com/api/graphql/guides/cam-assets
Working with asset types, properties, and asset hierarchy in the SensorUp Connected Asset Management (CAM) system.
# Connected Asset Management Guide
The Connected Asset Management (CAM) API provides comprehensive asset management capabilities for connected operations through the `su-cam-assets` subgraph. CAM handles asset types, asset properties, asset hierarchy, and geospatial operations.
## Overview
CAM enables you to:
* Define and manage **asset types** with custom property schemas
* Create and organize **assets** with hierarchical relationships
* Query assets by type, location, and properties
* Perform batch operations for large-scale asset management
* Track asset states and status changes
* Manage geospatial data and relationships
## Core Concepts
### Asset Types
Asset types define the schema and structure for assets. Each asset type specifies:
* **Properties**: Custom attributes and their data types
* **Hierarchy**: Parent-child relationships between assets
* **Extensions**: External data source integrations
* **Status tracking**: Asset state management configuration
### Assets
Assets are instances of asset types representing physical or logical entities in your connected operations:
* **Sites**: Top-level geographic locations
* **Equipment**: Major operational assets
* **Components**: Sub-components within equipment
* **Wells**: Oil and gas well assets
* **Pipelines**: Pipeline infrastructure
* **Unattributed**: Assets not yet assigned to a specific type
### Asset Hierarchy
Assets can be organized in parent-child relationships, enabling:
* Multi-level organizational structures
* Inherited properties and configurations
* Hierarchical queries and filtering
* Geographic nesting (e.g., equipment within sites)
## Querying Assets
### Get All Asset Types
```graphql theme={null}
query GetAssetTypes {
assetTypes {
all(first: 20) {
edges {
node {
assetTypeId
name
description
properties {
id
name
dataType
required
}
}
}
pageInfo {
hasNextPage
endCursor
}
}
}
}
```
### Get Specific Asset Type
```graphql theme={null}
query GetAssetType($assetTypeId: ID!) {
assetTypes {
byId(assetTypeId: $assetTypeId) {
assetTypeId
name
description
properties {
id
name
dataType
required
defaultValue
}
extensions {
id
name
connectionDetails {
... on AssetTypeExtensionConnectionSimple {
idProperty
idColumn
stateProperty
}
}
}
}
}
}
```
**Variables:**
```json theme={null}
{
"assetTypeId": "site"
}
```
### Query Assets by Type
```graphql theme={null}
query GetAssetsByType($assetTypeId: ID!) {
camAssets(assetTypeId: $assetTypeId) {
all(first: 20) {
edges {
node {
id
name
description
assetTypeId
active
geometry {
type
coordinates
}
properties
parent {
id
name
}
children {
id
name
assetTypeId
}
}
}
pageInfo {
hasNextPage
endCursor
}
}
}
}
```
**Variables:**
```json theme={null}
{
"assetTypeId": "equipment"
}
```
### Query Asset by ID
```graphql theme={null}
query GetAsset($id: ID!) {
camAssets {
byId(id: $id) {
id
name
description
assetTypeId
active
geometry {
type
coordinates
}
properties
parent {
id
name
assetTypeId
}
status {
statusId
label
setAt
setBy
}
}
}
}
```
**Variables:**
```json theme={null}
{
"id": "site-001"
}
```
### Filter and Search Assets
```graphql theme={null}
query SearchAssets($assetTypeId: ID!, $searchText: String!) {
camAssets(assetTypeId: $assetTypeId) {
all(
first: 20
fullTextSearch: { text: $searchText }
filter: { active: true }
) {
edges {
node {
id
name
description
assetTypeId
}
}
totalCount
}
}
}
```
**Variables:**
```json theme={null}
{
"assetTypeId": "site",
"searchText": "compressor"
}
```
## Creating and Updating Assets
### Create an Asset
```graphql theme={null}
mutation CreateAsset($input: CreateAssetInput!) {
createAsset(input: $input) {
asset {
id
name
assetTypeId
properties
}
correlationId
errors {
message
type
}
}
}
```
**Variables:**
```json theme={null}
{
"input": {
"assetId": "site-abc",
"name": "Compressor Station ABC",
"description": "Primary compression facility",
"assetTypeId": "site",
"active": true,
"group": "your-tenant-id",
"geometry": {
"type": "Point",
"coordinates": [-114.0719, 51.0447]
},
"propertyValues": [
{
"propertyId": "operator",
"value": "ACME Energy"
},
{
"propertyId": "capacity",
"value": "5000"
}
]
}
}
```
### Update Asset Properties
```graphql theme={null}
mutation UpdateAssetProperty($input: UpdateAssetPropertyInput!) {
updateAssetProperty(input: $input) {
asset {
id
properties
}
correlationId
errors {
message
type
}
}
}
```
**Variables:**
```json theme={null}
{
"input": {
"assetId": "site-abc",
"group": "your-tenant-id",
"propertyValues": [
{
"propertyId": "capacity",
"value": "6000"
}
]
}
}
```
### Update Asset Geometry
```graphql theme={null}
mutation UpdateAssetGeometry($input: UpdateAssetGeometryInput!) {
updateAssetGeometry(input: $input) {
asset {
id
geometry {
type
coordinates
}
}
correlationId
errors {
message
type
}
}
}
```
**Variables:**
```json theme={null}
{
"input": {
"assetId": "site-abc",
"group": "your-tenant-id",
"geometry": {
"type": "Polygon",
"coordinates": [[
[-114.073, 51.045],
[-114.071, 51.045],
[-114.071, 51.044],
[-114.073, 51.044],
[-114.073, 51.045]
]]
}
}
}
```
### Create Asset Status Record
```graphql theme={null}
mutation CreateAssetStatus($input: CreateAssetStatusInput!) {
createAssetStatus(input: $input) {
assetStatus {
assetId
statusId
label
setAt
setBy
}
correlationId
errors {
message
type
}
}
}
```
**Variables:**
```json theme={null}
{
"input": {
"assetId": "equipment-001",
"group": "your-tenant-id",
"statusId": "operational",
"label": "Fully Operational",
"notes": "Post-maintenance verification complete"
}
}
```
## Batch Operations
For large-scale asset creation or updates, CAM provides batch upsert capabilities.
### Generate Batch Upload URL
```graphql theme={null}
query GenerateUploadUrl($input: GenerateBatchUpsertUploadUrlInput!) {
generateBatchUpsertUploadUrl(input: $input) {
uploadUrl
batchUpsertReference
expiresAt
}
}
```
**Variables:**
```json theme={null}
{
"input": {
"assetTypeId": "equipment",
"fileFormat": "CSV",
"fileName": "equipment_batch_update.csv",
"fileSizeBytes": 2048000,
"group": "your-tenant-id",
"expirationMinutes": 60
}
}
```
### Upload File and Trigger Batch Upsert
```javascript theme={null}
// 1. Get the upload URL
const { data } = await client.query({
query: GENERATE_UPLOAD_URL,
variables: { input: uploadParams }
})
// 2. Upload file to S3
await fetch(data.generateBatchUpsertUploadUrl.uploadUrl, {
method: 'PUT',
headers: { 'Content-Type': 'text/csv' },
body: csvFileContent
})
// 3. Trigger batch processing
await client.mutate({
mutation: gql`
mutation BatchUpsert($ref: String!) {
manageCamAssets(dryRun: false) {
batchUpsert(batchUpsertReference: $ref) {
success
processedCount
errors {
row
message
}
}
}
}
`,
variables: {
ref: data.generateBatchUpsertUploadUrl.batchUpsertReference
}
})
```
## Asset Hierarchy Operations
### Query Asset Hierarchy
```graphql theme={null}
query GetAssetHierarchy($rootId: ID!) {
camAssets {
byId(id: $rootId) {
id
name
assetTypeId
children {
id
name
assetTypeId
children {
id
name
assetTypeId
}
}
}
}
}
```
### Create Child Asset
```graphql theme={null}
mutation CreateChildAsset($input: CreateAssetInput!) {
createAsset(input: $input) {
asset {
id
name
parent {
id
name
}
}
correlationId
errors {
message
type
}
}
}
```
**Variables:**
```json theme={null}
{
"input": {
"assetId": "compressor-001",
"name": "Compressor Unit 1",
"assetTypeId": "equipment",
"active": true,
"group": "your-tenant-id",
"parent": {
"assetId": "site-abc",
"assetTypeId": "site"
},
"geometry": {
"type": "Point",
"coordinates": [-114.0720, 51.0448]
}
}
}
```
## Geospatial Queries
CAM supports full GeoJSON geometry types for asset locations:
### Query Assets by Bounding Box
```graphql theme={null}
query GetAssetsInBounds(
$assetTypeId: ID!
$minLon: Float!
$minLat: Float!
$maxLon: Float!
$maxLat: Float!
) {
camAssets(assetTypeId: $assetTypeId) {
all(
first: 100
filter: {
geometry: {
bbox: [$minLon, $minLat, $maxLon, $maxLat]
}
}
) {
edges {
node {
id
name
geometry {
type
coordinates
bbox
}
}
}
}
}
}
```
### Supported Geometry Types
CAM supports all GeoJSON geometry types:
* **Point**: Single location `[-114.0719, 51.0447]`
* **LineString**: Linear features (pipelines, roads)
* **Polygon**: Areas and boundaries
* **MultiPoint**, **MultiLineString**, **MultiPolygon**: Collections
* **GeometryCollection**: Mixed geometry types
## Asset References
Query lightweight asset references for dropdowns and lookups:
```graphql theme={null}
query GetAssetReferences {
camAssetReferences {
all(first: 100) {
edges {
node {
id
name
assetTypeId
}
}
}
}
}
```
## CAM Engine and Datasets
Query available datasets and engine configuration:
```graphql theme={null}
query GetCamEngine {
camEngine {
datasets {
id
name
assetTypeId
sourceType
}
}
}
```
### Get Datasets for Tenant
```graphql theme={null}
query GetCamDatasets($group: ID!) {
camAssetsDatasets(group: $group) {
dataset
displayName
assetTypeId
}
}
```
## Asset Configuration
Manage tenant-specific asset configurations:
```graphql theme={null}
query GetAssetConfigs($group: ID!) {
assetConfigs(group: $group) {
all {
id
value
}
}
}
```
### Set Configuration
```graphql theme={null}
mutation SetAssetConfig($group: ID!, $id: ID!, $value: JSONObject!) {
setAssetConfig(group: $group, id: $id, value: $value) {
config {
id
value
}
correlationId
errors {
message
type
}
}
}
```
## Best Practices
### 1. Use Asset Type Filtering
Always filter by `assetTypeId` when querying assets to improve performance:
```graphql theme={null}
# Good - filtered by type
camAssets(assetTypeId: "equipment") { all(first: 20) { ... } }
# Less efficient - all asset types
camAssets { all(first: 20) { ... } }
```
### 2. Batch Operations for Scale
For bulk operations (>100 assets), use batch upsert instead of individual mutations:
```graphql theme={null}
# Good for >100 assets
generateBatchUpsertUploadUrl → upload CSV → manageCamAssets.batchUpsert
# Use individual mutations for <100 assets
createAsset, updateAsset
```
### 3. Request Only Needed Fields
Minimize query size by selecting only required fields:
```graphql theme={null}
# Good - specific fields
camAssets { byId(id: "x") { id name } }
# Avoid - requesting all properties
camAssets { byId(id: "x") { id name properties ... } }
```
### 4. Use Asset References for Lookups
For dropdowns and selection lists, use `camAssetReferences` instead of full `camAssets`:
```graphql theme={null}
# Good - lightweight references
camAssetReferences { all { edges { node { id name } } } }
# Avoid - full asset queries for simple lookups
camAssets { all { edges { node { id name ... } } } }
```
### 5. Leverage Asset Hierarchy
Use parent-child relationships instead of flat structures:
```graphql theme={null}
# Good - hierarchical query
camAssets {
byId(id: "site-001") {
children { # Equipment at site
children { # Components on equipment
id
name
}
}
}
}
```
## Error Handling
CAM mutations return errors in the standard format:
```json theme={null}
{
"data": {
"createAsset": {
"asset": null,
"correlationId": "abc-123",
"errors": [
{
"message": "Asset with ID 'site-abc' already exists",
"type": "DUPLICATE_ID"
}
]
}
}
}
```
Common error types:
* `DUPLICATE_ID`: Asset ID already exists
* `INVALID_PARENT`: Parent asset not found or invalid type
* `INVALID_PROPERTY`: Property validation failed
* `INVALID_GEOMETRY`: GeoJSON geometry is malformed
* `MISSING_REQUIRED`: Required field not provided
## Related Resources
* **[Subgraph Reference](../subgraphs/cam-assets)** - Complete schema documentation
* **[Common Patterns](../common-patterns)** - Pagination and filtering
* **[Field Service Guide](./field-service)** - Mobile workflows using assets
* **[Core Platform Guide](./core-platform)** - Maps and geospatial services
# Core Platform Guide
Source: https://docs.sensorup.com/api/graphql/guides/core-platform
Working with platform services including authentication, user management, geospatial operations, data catalogs, and event streaming.
# Core Platform Guide
The Core Platform API provides foundational services that underpin all SensorUp operations. It includes authentication (`su-auth`), user management (`su-user`), core infrastructure (`su-backend`), geospatial services (`su-maps`), data catalogs (`su-catalog`), and event streaming (`su-eventhub`).
## Overview
The Core Platform enables:
* **Authentication**: Session management, API keys, and federated sign-in
* **User Management**: User profiles, permissions, and device tracking
* **Geospatial Services**: Maps, location queries, and spatial operations
* **Data Catalogs**: Schema registry and metadata management
* **Event Streaming**: Real-time event subscriptions and notifications
* **Core Infrastructure**: Configuration, health checks, and system operations
## Authentication (su-auth)
For comprehensive authentication documentation, see the **[Authentication Guide](../authentication)**.
### Quick Reference
**Session-based Authentication:**
```graphql theme={null}
mutation SignIn($input: AuthSignInInput!) {
signIn(input: $input) {
session {
username
authenticated
expiresAt
expiresAtHard
userGroup
}
correlationId
errors { message type }
}
}
```
**Check Current Session:**
```graphql theme={null}
query {
session {
username
authenticated
expiresAt
userGroup
lastAuthenticatedAt
}
}
```
**API Key Creation:**
```graphql theme={null}
mutation CreateAPIKey($input: AuthCreateAPIKeyInput!) {
createAPIKey(input: $input) {
apiKey {
apiKeyId
apiKeySessionId
expiresAt
}
correlationId
errors { message type }
}
}
```
### Session Lifetimes
| Client Type | Hard Expiry | Soft Expiry (Idle) |
| - | - | - |
| Explorer (Web) | 30 days | 7 days |
| SensorHub Android | 365 days | 60 days |
| SensorHub iOS | 365 days | 60 days |
| API Key | 365 days | 60 days |
### Authentication Methods
* **Cookie**: `sensorup_sessionid` (auto-set in browser)
* **Header**: `x-sensorup-sessionid` (for API clients and M2M)
```bash theme={null}
curl -X POST https://customer-demo.sensorup.com/api/graphql \
-H "Content-Type: application/json" \
-H "x-sensorup-sessionid: YOUR_SESSION_ID" \
-d '{"query":"{ session { username } }"}'
```
## User Management (su-user)
### Query User Profile
```graphql theme={null}
query GetUser($userId: ID!) {
user(id: $userId) {
userId
username
email
firstName
lastName
phoneNumber
preferredLanguage
timezone
groups
permissions {
resource
actions
}
devices {
deviceKey
name
remembered
lastSignedInAt
lastIpAddress
}
}
}
```
### Update User Profile
```graphql theme={null}
mutation UpdateUser($input: UpdateUserInput!) {
updateUser(input: $input) {
user {
userId
firstName
lastName
email
phoneNumber
}
correlationId
errors {
message
type
}
}
}
```
**Variables:**
```json theme={null}
{
"input": {
"userId": "user-123",
"firstName": "John",
"lastName": "Smith",
"phoneNumber": "+1-555-0100",
"timezone": "America/Edmonton"
}
}
```
### Query User Permissions
```graphql theme={null}
query GetUserPermissions($userId: ID!) {
user(id: $userId) {
userId
username
groups
permissions {
resource
actions
scope
}
roles {
roleId
roleName
permissions {
resource
actions
}
}
}
}
```
### List Users in Group
```graphql theme={null}
query GetGroupUsers($group: ID!) {
users(group: $group) {
all(first: 100) {
edges {
node {
userId
username
email
firstName
lastName
active
}
}
pageInfo {
hasNextPage
endCursor
}
}
}
}
```
### Device Management
```graphql theme={null}
query GetUserDevices($userId: ID!) {
user(id: $userId) {
devices {
deviceKey
name
remembered
createdAt
lastSignedInAt
lastIpAddress
userAgent
}
}
}
```
**Forget Device:**
```graphql theme={null}
mutation ForgetDevice($input: AuthForgetSpecificDevicesInput!) {
forgetDevices(input: $input) {
session {
username
}
correlationId
errors { message type }
}
}
```
## Geospatial Services (su-maps)
### Query Map Configuration
```graphql theme={null}
query GetMapConfig {
maps {
config {
defaultCenter {
lat
lon
}
defaultZoom
baseLayers {
id
name
type
url
attribution
}
overlayLayers {
id
name
type
url
}
}
}
}
```
### Get Map Tiles
```graphql theme={null}
query GetMapTiles($bounds: BoundsInput!, $zoom: Int!) {
maps {
tiles(bounds: $bounds, zoom: $zoom) {
tileUrl
bounds {
north
south
east
west
}
zoom
}
}
}
```
**Variables:**
```json theme={null}
{
"bounds": {
"north": 51.1,
"south": 51.0,
"east": -114.0,
"west": -114.1
},
"zoom": 12
}
```
### Geocoding
```graphql theme={null}
query Geocode($address: String!) {
maps {
geocode(address: $address) {
results {
formattedAddress
geometry {
location {
lat
lon
}
bounds {
north
south
east
west
}
}
placeId
types
}
}
}
}
```
**Variables:**
```json theme={null}
{
"address": "Calgary, Alberta, Canada"
}
```
### Reverse Geocoding
```graphql theme={null}
query ReverseGeocode($lat: Float!, $lon: Float!) {
maps {
reverseGeocode(lat: $lat, lon: $lon) {
results {
formattedAddress
addressComponents {
longName
shortName
types
}
placeId
}
}
}
}
```
**Variables:**
```json theme={null}
{
"lat": 51.0447,
"lon": -114.0719
}
```
### Spatial Queries
```graphql theme={null}
query FindNearbyAssets($location: LocationInput!, $radiusKm: Float!) {
maps {
findNearby(location: $location, radius: $radiusKm) {
results {
id
type
distance
geometry {
type
coordinates
}
properties
}
}
}
}
```
**Variables:**
```json theme={null}
{
"location": {
"lat": 51.0447,
"lon": -114.0719
},
"radiusKm": 10.0
}
```
### GeoJSON Support
The platform supports full GeoJSON geometry types:
```graphql theme={null}
type GeoJSONGeometry {
type: GeoJSONType! # Point, LineString, Polygon, etc.
coordinates: GeoJSONCoordinates
bbox: [Float]
}
enum GeoJSONType {
Point
MultiPoint
LineString
MultiLineString
Polygon
MultiPolygon
GeometryCollection
Feature
FeatureCollection
}
```
**Example Point:**
```json theme={null}
{
"type": "Point",
"coordinates": [-114.0719, 51.0447]
}
```
**Example Polygon:**
```json theme={null}
{
"type": "Polygon",
"coordinates": [[
[-114.073, 51.045],
[-114.071, 51.045],
[-114.071, 51.044],
[-114.073, 51.044],
[-114.073, 51.045]
]]
}
```
## Data Catalogs (su-catalog)
### Query Catalog Entries
```graphql theme={null}
query GetCatalogEntries {
catalog {
entries(first: 100) {
edges {
node {
id
name
description
schema
dataType
category
tags
createdAt
updatedAt
}
}
pageInfo {
hasNextPage
endCursor
}
}
}
}
```
### Get Specific Catalog Entry
```graphql theme={null}
query GetCatalogEntry($id: ID!) {
catalog {
entry(id: $id) {
id
name
description
schema
dataType
category
tags
metadata
validationRules {
rule
message
}
}
}
}
```
### Create Catalog Entry
```graphql theme={null}
mutation CreateCatalogEntry($input: CreateCatalogEntryInput!) {
createCatalogEntry(input: $input) {
catalogEntry {
id
name
schema
}
correlationId
errors {
message
type
}
}
}
```
**Variables:**
```json theme={null}
{
"input": {
"id": "pressure-reading",
"name": "Pressure Reading",
"description": "Equipment pressure sensor reading",
"dataType": "numeric",
"schema": {
"type": "object",
"properties": {
"value": { "type": "number" },
"unit": { "type": "string", "enum": ["psi", "kPa", "bar"] },
"timestamp": { "type": "string", "format": "date-time" }
},
"required": ["value", "unit", "timestamp"]
},
"category": "sensor-data",
"tags": ["pressure", "sensor", "telemetry"]
}
}
```
### Query by Category
```graphql theme={null}
query GetCatalogByCategory($category: String!) {
catalog {
byCategory(category: $category) {
id
name
description
dataType
}
}
}
```
**Variables:**
```json theme={null}
{
"category": "sensor-data"
}
```
## Event Streaming (su-eventhub)
### Subscribe to Events
```graphql theme={null}
subscription OnEvents($filter: EventFilter) {
events(filter: $filter) {
eventId
eventType
source
timestamp
data
correlationId
}
}
```
**Variables (Filter by Event Type):**
```json theme={null}
{
"filter": {
"eventTypes": ["ASSET_CREATED", "ASSET_UPDATED", "ISSUE_CREATED"]
}
}
```
### Publish Event
```graphql theme={null}
mutation PublishEvent($input: PublishEventInput!) {
publishEvent(input: $input) {
event {
eventId
eventType
timestamp
}
correlationId
errors {
message
type
}
}
}
```
**Variables:**
```json theme={null}
{
"input": {
"eventType": "CUSTOM_EVENT",
"source": "integration-service",
"data": {
"action": "data_sync_completed",
"recordsProcessed": 1500,
"duration": 45.2
}
}
}
```
### Query Event History
```graphql theme={null}
query GetEventHistory($filter: EventFilter!, $first: Int!) {
eventHub {
history(filter: $filter, first: $first) {
edges {
node {
eventId
eventType
source
timestamp
data
}
}
pageInfo {
hasNextPage
endCursor
}
}
}
}
```
**Variables:**
```json theme={null}
{
"filter": {
"eventTypes": ["ASSET_CREATED"],
"from": "2025-11-01T00:00:00Z",
"to": "2025-11-05T23:59:59Z"
},
"first": 100
}
```
### Event Types
Common system event types:
| Event Type | Description |
| - | - |
| `ASSET_CREATED` | New asset created |
| `ASSET_UPDATED` | Asset modified |
| `ASSET_DELETED` | Asset removed |
| `ISSUE_CREATED` | New issue opened |
| `ISSUE_UPDATED` | Issue modified |
| `ISSUE_CLOSED` | Issue resolved and closed |
| `DETECTION_CREATED` | New detection recorded |
| `FORM_SUBMITTED` | XForm response submitted |
| `USER_SIGNED_IN` | User authentication |
| `API_KEY_CREATED` | New API key generated |
## Core Infrastructure (su-backend)
### System Configuration
```graphql theme={null}
query GetConfig {
config {
environment
version
features {
name
enabled
configuration
}
auth {
loginEnabled
ssoEnabled
ssoUrl
mfaRequired
}
integrations {
name
type
endpoint
active
}
}
}
```
### Health Check
```graphql theme={null}
query HealthCheck {
health {
status
version
timestamp
services {
name
status
latency
lastCheck
}
}
}
```
### Feature Flags
```graphql theme={null}
query GetFeatureFlags {
features {
all {
featureId
name
enabled
rolloutPercentage
conditions {
type
value
}
}
}
}
```
**Check Specific Feature:**
```graphql theme={null}
query IsFeatureEnabled($featureId: ID!, $context: FeatureContext) {
features {
isEnabled(featureId: $featureId, context: $context)
}
}
```
### System Metrics
```graphql theme={null}
query GetSystemMetrics {
metrics {
apiCalls {
total
byEndpoint {
endpoint
count
avgLatency
}
}
errors {
total
byType {
type
count
}
}
performance {
avgResponseTime
p95ResponseTime
p99ResponseTime
}
}
}
```
## Common Patterns
### Authentication Flow
```javascript theme={null}
// 1. Sign in
const { data } = await client.mutate({
mutation: SIGN_IN,
variables: {
input: {
loginUsername: 'user@example.com',
password: 'password',
clientApplicationType: 'EXPLORER'
}
}
})
// 2. Store session ID
const sessionId = data.signIn.session.sessionId
// 3. Use in subsequent requests
const result = await fetch('https://customer-demo.sensorup.com/api/graphql', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
'x-sensorup-sessionid': sessionId
},
body: JSON.stringify({ query: '{ session { username } }' })
})
```
### Geospatial Queries
```javascript theme={null}
// Find assets near a location
async function findAssetsNearLocation(lat, lon, radiusKm) {
const { data } = await client.query({
query: FIND_NEARBY,
variables: { location: { lat, lon }, radiusKm }
})
return data.maps.findNearby.results
}
// Geocode an address
async function getCoordinates(address) {
const { data } = await client.query({
query: GEOCODE,
variables: { address }
})
return data.maps.geocode.results[0].geometry.location
}
```
### Event Streaming
```javascript theme={null}
// Subscribe to real-time events
const subscription = client.subscribe({
query: ON_EVENTS,
variables: {
filter: {
eventTypes: ['ASSET_CREATED', 'ISSUE_CREATED']
}
}
}).subscribe({
next: ({ data }) => {
console.log('New event:', data.events)
handleEvent(data.events)
},
error: (error) => console.error('Subscription error:', error)
})
// Cleanup
subscription.unsubscribe()
```
### Catalog-Driven Forms
```javascript theme={null}
// Use catalog to validate form data
async function validateFormData(dataType, data) {
// Get schema from catalog
const { data: catalogData } = await client.query({
query: GET_CATALOG_ENTRY,
variables: { id: dataType }
})
const schema = catalogData.catalog.entry.schema
// Validate against schema
const valid = validateAgainstJsonSchema(data, schema)
return valid
}
```
## Best Practices
### 1. Session Management
Monitor session expiration and refresh proactively:
```javascript theme={null}
// Check session expiration
const { data } = await client.query({ query: GET_SESSION })
const expiresAt = new Date(data.session.expiresAt)
const now = new Date()
// Refresh if expiring soon (within 1 hour)
if (expiresAt - now < 3600000) {
await refreshSession()
}
```
### 2. Geospatial Performance
Use appropriate zoom levels and bounds for map tiles:
```graphql theme={null}
# Good - reasonable bounds
maps { tiles(bounds: { ... }, zoom: 12) }
# Avoid - excessive detail over large area
maps { tiles(bounds: { ... }, zoom: 18) }
```
### 3. Event Filtering
Subscribe only to needed event types:
```graphql theme={null}
# Good - filtered subscription
subscription { events(filter: { eventTypes: ["ASSET_CREATED"] }) }
# Avoid - unfiltered (high volume)
subscription { events }
```
### 4. Catalog Validation
Leverage catalog schemas for data validation:
```graphql theme={null}
# 1. Get schema from catalog
catalog { entry(id: "sensor-reading") { schema } }
# 2. Validate data client-side before submission
# 3. Submit validated data
```
### 5. Permission Checks
Always verify user permissions before restricted operations:
```graphql theme={null}
query CheckPermission($userId: ID!, $resource: String!, $action: String!) {
user(id: $userId) {
permissions {
resource
actions
}
}
}
```
## Error Handling
Platform mutations return consistent error formats:
```json theme={null}
{
"data": {
"updateUser": {
"user": null,
"correlationId": "abc-123",
"errors": [
{
"message": "Invalid email address format",
"type": "VALIDATION_ERROR"
}
]
}
}
}
```
Common error types:
* `AUTHENTICATION_FAILED`: Invalid credentials
* `AUTHORIZATION_FAILED`: Insufficient permissions
* `VALIDATION_ERROR`: Input validation failed
* `NOT_FOUND`: Resource does not exist
* `DUPLICATE`: Resource already exists
* `RATE_LIMIT_EXCEEDED`: Too many requests
## Related Resources
* **[Authentication Guide](../authentication)** - Comprehensive auth documentation
* **[Auth Subgraph Reference](../subgraphs/auth)** - Complete auth schema
* **[User Subgraph Reference](../subgraphs/user)** - User management schema
* **[Maps Subgraph Reference](../subgraphs/maps)** - Geospatial schema
* **[Catalog Subgraph Reference](../subgraphs/catalog)** - Catalog schema
* **[EventHub Subgraph Reference](../subgraphs/eventhub)** - Event streaming schema
* **[Backend Subgraph Reference](../subgraphs/backend)** - Core infrastructure schema
* **[Common Patterns](../common-patterns)** - Pagination, filtering, and error handling
# Emissions & LDAR API Guide
Source: https://docs.sensorup.com/api/graphql/guides/emissions
Learn how to work with emission observations, LDAR workflows, reconciliation, and detection ingestion.
# Emissions & LDAR API Guide
The Emissions API provides comprehensive Leak Detection and Repair (LDAR) capabilities through three specialized subgraphs: `su-methane-ldar-backend`, `su-methane-reconcile-backend`, and `su-detections-ingress`.
## Overview
The Emissions API enables you to:
* Track and manage emission observations (detections)
* Coordinate LDAR inspection workflows
* Reconcile emissions for compliance reporting
* Ingest detection data from various sources
### Key Concepts
* **Emission Observation**: A detected emission event requiring investigation
* **Detection**: Raw detection data from sensors, flyovers, satellites, etc.
* **Inspection Request**: Request for follow-up inspection (OGI, drone, visual)
* **Reconciliation**: Process of matching emissions to compliance requirements
* **Clue**: Additional context about a detection (equipment, location, etc.)
## Emission Observations
### Query Emission Observations
```graphql theme={null}
query GetEmissionObservations($first: Int!, $after: String) {
emissionObservations {
all(first: $first, after: $after) {
edges {
node {
id
displayName
priority
status
detectionType
phenomenonTime
receivedAt
geometry {
type
coordinates
}
audit {
createdTime
acknowledgedTime
acknowledgedBy {
userId
}
}
}
}
pageInfo {
hasNextPage
endCursor
}
}
}
}
```
### Get Specific Emission Observation
```graphql theme={null}
query GetEmissionObservation($id: ID!) {
emissionObservations {
byId(id: $id) {
id
displayName
priority
status
detectionType
phenomenonTime
geometry {
type
coordinates
}
clues {
clueId
clue {
displayName
equipment {
id
name
}
}
}
inspectionRequests {
inspectionRequestId
inspectionRequest {
id
inspectionType
status
additionalComment
}
}
}
}
}
```
## Detection Types
| Type | Description | Common Source |
| - | - | - |
| `DETECTION_TYPE_SATELLITE` | Satellite-based detection | Remote sensing |
| `DETECTION_TYPE_FLYOVER` | Aircraft-based detection | Aerial surveys |
| `DETECTION_TYPE_DRONE` | Drone-based detection | UAV inspection |
| `DETECTION_TYPE_OGI` | Optical Gas Imaging | Ground inspection |
| `DETECTION_TYPE_CMS` | Continuous Monitoring System | Fixed sensors |
| `DETECTION_TYPE_OWD` | On-site Walk Down | Manual inspection |
| `DETECTION_TYPE_VENTING_FLARING_BLOWDOWN` | Planned releases | Operations |
## Detection Status Workflow
```mermaid theme={null}
stateDiagram-v2
[*] --> NEW
NEW --> VISUAL_INSPECTION_SCHEDULED
VISUAL_INSPECTION_SCHEDULED --> VISUAL_INSPECTION_COMPLETED
VISUAL_INSPECTION_COMPLETED --> OGI_REQUESTED
OGI_REQUESTED --> OGI_SCHEDULED
OGI_SCHEDULED --> OGI_COMPLETED
OGI_COMPLETED --> LEAK_REPAIR_SCHEDULED
LEAK_REPAIR_SCHEDULED --> LEAK_REPAIRED
LEAK_REPAIRED --> VERIFICATION_SCHEDULED
VERIFICATION_SCHEDULED --> RESOLVED
RESOLVED --> [*]
NEW: New Detection
VISUAL_INSPECTION_SCHEDULED: Visual Inspection Scheduled
VISUAL_INSPECTION_COMPLETED: Visual Inspection Completed
OGI_REQUESTED: OGI Requested
OGI_SCHEDULED: OGI Scheduled
OGI_COMPLETED: OGI Completed
LEAK_REPAIR_SCHEDULED: Leak Repair Scheduled
LEAK_REPAIRED: Leak Repaired
VERIFICATION_SCHEDULED: Verification Scheduled
RESOLVED: Resolved
```
## Priority Levels
| Priority | Integer Value | Description |
| - | - | - |
| `DETECTION_PRIORITY_HIGH` | 100 | Requires immediate attention |
| `DETECTION_PRIORITY_MEDIUM` | 50 | Normal priority |
| `DETECTION_PRIORITY_LOW` | 1 | Low priority or informational |
## Inspection Requests
Inspection requests coordinate follow-up investigations of emission observations.
### Create Inspection Request
```graphql theme={null}
mutation CreateInspectionRequest($input: CreateInspectionRequestInput!) {
createInspectionRequest(input: $input) {
inspectionRequest {
id
detectionReference {
detectionId
}
inspectionType
status
additionalComment
audit {
createdTime
createdBy {
userId
}
}
}
correlationId
errors {
message
type
}
}
}
```
**Variables:**
```json theme={null}
{
"input": {
"detectionReference": {
"detectionId": "detection-123"
},
"inspectionType": "INSPECTION_OGI",
"additionalComment": "High priority - investigate equipment leak",
"clues": [
{
"clueId": "clue-456"
}
],
"requestedBy": {
"givenName": "John",
"familyName": "Doe",
"email": "john.doe@example.com"
}
}
}
```
### Update Inspection Request
```graphql theme={null}
mutation UpdateInspectionRequest($input: UpdateInspectionRequestInput!) {
updateInspectionRequest(input: $input) {
inspectionRequest {
id
status
additionalComment
}
correlationId
errors {
message
type
}
}
}
```
### Query Inspection Requests
```graphql theme={null}
query GetInspectionRequests($detectionId: ID!) {
emissionObservations {
byId(id: $detectionId) {
inspectionRequests {
inspectionRequestId
inspectionRequest {
id
inspectionType
status
additionalComment
requestedBy {
givenName
familyName
email
}
audit {
createdTime
updatedTime
}
}
}
}
}
}
```
## Inspection Types
| Type | Description | Typical Use |
| - | - | - |
| `INSPECTION_OGI` | Optical Gas Imaging | Confirm and locate leaks |
| `INSPECTION_DRONE` | Drone inspection | Aerial investigation |
## Clues (Equipment Context)
Clues provide context about where an emission was detected.
### Query Clues for Detection
```graphql theme={null}
query GetDetectionClues($detectionId: ID!) {
emissionObservations {
byId(id: $detectionId) {
clues {
clueId
clue {
displayName
equipment {
id
name
description
siteReference {
siteId
}
components {
name
componentType
}
}
}
}
}
}
}
```
### Equipment Components
```graphql theme={null}
query GetEquipmentComponents($equipmentId: ID!) {
equipment {
byId(id: $equipmentId) {
id
name
components {
name
componentType
description
}
}
}
}
```
## Resolution Modes
When resolving emission observations:
| Mode | Description |
| - | - |
| `DETECTION_RESOLVED_CORRELATED` | Correlated with another detection |
| `DETECTION_RESOLVED_FALSE_ALARM` | Determined to be false positive |
| `DETECTION_RESOLVED_READY_TO_RECONCILE` | Ready for compliance reconciliation |
### Resolve Detection
```graphql theme={null}
mutation ResolveDetection($input: ResolveDetectionInput!) {
resolveDetection(input: $input) {
emissionObservation {
id
status
resolutionMode
}
correlationId
errors {
message
type
}
}
}
```
**Variables:**
```json theme={null}
{
"input": {
"detectionId": "detection-123",
"resolutionMode": "DETECTION_RESOLVED_READY_TO_RECONCILE",
"notes": "Verified and repaired, ready for compliance reporting"
}
}
```
## Emission Observation Reports
### Query Reports by Site and Month
```graphql theme={null}
query GetEmissionReports($siteId: ID!, $month: String!) {
sites {
byId(id: $siteId) {
emissionObservationReports(month: $month) {
edges {
node {
month
totalDetections
resolvedDetections
pendingDetections
highPriorityCount
complianceStatus
}
}
}
}
}
}
```
**Variables:**
```json theme={null}
{
"siteId": "site-123",
"month": "2025-11"
}
```
### Filter Reports
```graphql theme={null}
query FilteredReports($filter: InboxDetectionFilter!) {
emissionObservations {
reports(filter: $filter) {
edges {
node {
id
displayName
priority
status
}
}
}
}
}
```
## Detection Ingress
The `su-detections-ingress` subgraph handles incoming detection data.
### Query Available Datasets
```graphql theme={null}
query GetDetectionDatasets($group: ID) {
detectionsIngressDatasets(group: $group) {
datasetId
metadataJson
}
}
```
### Reload Datasets
```graphql theme={null}
mutation ReloadDatasets($group: ID) {
reloadDetectionsIngressDatasets(group: $group) {
datasetId
metadataJson
}
}
```
## Reconciliation Workflow
The `su-methane-reconcile-backend` handles compliance reconciliation.
### Query Reconciliation Status
```graphql theme={null}
query GetReconciliationStatus($siteId: ID!, $month: String!) {
reconciliation {
bySiteAndMonth(siteId: $siteId, month: $month) {
status
totalEmissions
reconciledEmissions
pendingEmissions
complianceSeverity
lastUpdated
}
}
}
```
### Submit for Reconciliation
```graphql theme={null}
mutation SubmitForReconciliation($input: SubmitReconciliationInput!) {
submitForReconciliation(input: $input) {
reconciliation {
id
status
submittedAt
}
correlationId
errors {
message
type
}
}
}
```
## Compliance Severity
| Severity | Description |
| - | - |
| `HIGH` | Critical compliance issue |
| `MEDIUM` | Moderate compliance concern |
| `LOW` | Minor compliance matter |
## Geospatial Queries
### Get Detections Near Location
```graphql theme={null}
query GetNearbyDetections($center: GeoJSONGeometryInput!, $radius: Float!) {
emissionObservations {
near(center: $center, radius: $radius) {
edges {
node {
id
displayName
geometry {
type
coordinates
}
distance
}
}
}
}
}
```
**Variables:**
```json theme={null}
{
"center": {
"type": "Point",
"coordinates": [-114.0719, 51.0447]
},
"radius": 1000
}
```
## Audit & Acknowledgment
### Acknowledge Detection
```graphql theme={null}
mutation AcknowledgeDetection($input: AcknowledgeDetectionInput!) {
acknowledgeDetection(input: $input) {
emissionObservation {
id
audit {
acknowledgedTime
acknowledgedBy {
userId
}
}
}
correlationId
errors {
message
type
}
}
}
```
### Query Acknowledgment History
```graphql theme={null}
query GetAcknowledgmentHistory($detectionId: ID!) {
emissionObservations {
byId(id: $detectionId) {
audit {
createdTime
createdBy {
userId
}
updatedTime
updatedBy {
userId
}
acknowledgedTime
acknowledgedBy {
userId
}
}
}
}
}
```
## Common Patterns
### Processing New Detections
```javascript theme={null}
// Query new detections
const newDetections = await query(`
query {
emissionObservations {
all(first: 100, filter: { status: DETECTION_STATUS_NEW }) {
edges {
node {
id
priority
detectionType
phenomenonTime
}
}
}
}
}
`)
// Prioritize and create inspection requests
for (const detection of newDetections.filter(d => d.priority === 'HIGH')) {
await createInspectionRequest({
detectionId: detection.id,
inspectionType: 'INSPECTION_OGI'
})
}
```
### Tracking Inspection Progress
```javascript theme={null}
const inspectionStatuses = [
'INSPECTION_STATUS_REQUESTED',
'INSPECTION_STATUS_SCHEDULED',
'INSPECTION_STATUS_COMPLETED'
]
for (const status of inspectionStatuses) {
const count = await countInspections({ status })
console.log(`${status}: ${count} inspections`)
}
```
## Best Practices
1. **Prioritize high-severity detections**: Focus on `DETECTION_PRIORITY_HIGH` first
2. **Track acknowledgment**: Always acknowledge when reviewing detections
3. **Use clues for context**: Clues help identify specific equipment and components
4. **Monitor status transitions**: Track detections through the complete workflow
5. **Coordinate inspections**: Link inspection requests to specific detections
6. **Reconcile regularly**: Don't let pending emissions accumulate
7. **Use geospatial queries**: Find nearby detections to optimize field work
8. **Archive resolved detections**: Keep historical data for compliance
## Related Resources
* **[LDAR Backend Reference](../subgraphs/methane-ldar-backend)** - Complete schema
* **[Reconcile Backend Reference](../subgraphs/methane-reconcile-backend)** - Reconciliation schema
## Schema Reference
* [su-methane-ldar-backend SDL](../schemas/sdl/su-methane-ldar-backend.graphql)
* [su-methane-reconcile-backend SDL](../schemas/sdl/su-methane-reconcile-backend.graphql)
* [su-detections-ingress SDL](../schemas/sdl/su-detections-ingress.graphql)
# Field Service Management Guide
Source: https://docs.sensorup.com/api/graphql/guides/field-service
Working with mobile workflows, issue tracking, task management, and data collection forms for field service operations.
# Field Service Management Guide
The Field Service Management (FSM) API enables mobile workflows through issue tracking, task management, and dynamic data collection forms. FSM integrates four subgraphs: `su-assets` (form subjects), `su-issues` (issue tracking), `su-workflow` (workflow orchestration), and `su-forms` (data collection).
## Overview
FSM enables field teams to:
* Track **issues** and work items requiring attention
* Execute **workflows** with defined states and transitions
* Complete **tasks** using dynamic XForms
* Reference **asset profiles** as subjects for field work
* Collect structured data through mobile applications
* Manage multi-step inspection campaigns
## Core Concepts
### Asset Profiles (Form Subjects)
Asset profiles (`su-assets`) define the subjects that field teams work on during mobile workflows. These are NOT the same as CAM assets:
* **Asset Profile**: Schema definition for form subjects (e.g., "Well Inspection", "Equipment Survey")
* **Asset**: Instance of a profile used as a form subject
* **Properties**: Attributes collected about the subject
* **Relationships**: Connections between assets and other entities
Asset profiles serve as the foundation for tasks and forms in mobile applications.
### Issues
Issues represent trackable work items requiring attention or resolution:
* **Issue Types**: `ISSUE`, `TASK`, `MULTITASK`, `SUBTASK`
* **Status**: `OPEN`, `IN_PROGRESS`, `RESOLVED`, `CLOSED`, `CANCELLED`
* **Subject**: The entity the issue relates to (e.g., an asset profile instance)
* **Trigger**: What caused the issue (e.g., a detection, event, or manual creation)
### Tasks
Tasks are specific work to be performed by field personnel:
* **Form-based Tasks**: Tasks with an associated XForm for data collection
* **General Tasks**: Simple work items without form requirements
* **Multi-tasks**: Parent tasks coordinating multiple subtasks
* **Subtasks**: Individual tasks within a multi-task campaign
### XForms
Dynamic data collection forms based on the ODK XForms standard:
* **Controls**: Input fields (text, select, date, location, etc.)
* **Groups**: Logical sections organizing related questions
* **Repeats**: Repeating sections for multiple observations
* **Constraints**: Validation rules and calculations
* **Relevance**: Conditional display logic
### Workflows
State machines defining the lifecycle of issues and tasks:
* **States**: Valid statuses an issue can have
* **Transitions**: Allowed movements between states
* **Guards**: Conditions required for transitions
* **Actions**: Side effects triggered during transitions
## Asset Profiles for Field Work
### Query Available Profiles
```graphql theme={null}
query GetAssetProfiles {
assetProfiles {
all(first: 20) {
edges {
node {
profile
title
displayNameProperty
descriptionProperty
properties {
id
name
dataType
required
}
relationships {
relationship
type
profile
referenceProperty
}
}
}
pageInfo {
hasNextPage
endCursor
}
}
}
}
```
### Get Specific Profile
```graphql theme={null}
query GetAssetProfile($profile: ID!) {
assetProfiles {
byId(profile: $profile) {
profile
title
displayNameProperty
views {
view
title
fields
}
filters {
filter
displayName
filterString
}
}
}
}
```
**Variables:**
```json theme={null}
{
"profile": "well-inspection"
}
```
### Query Assets (Form Subjects)
```graphql theme={null}
query GetAssets($profile: ID!, $first: Int!) {
assets(profile: $profile) {
all(first: $first) {
edges {
node {
id
displayName
properties
geometry {
type
coordinates
}
relationships {
... on AssetRelationshipOne {
asset {
id
displayName
}
}
}
}
}
pageInfo {
hasNextPage
endCursor
}
}
}
}
```
**Variables:**
```json theme={null}
{
"profile": "well-inspection",
"first": 50
}
```
### Create Asset (Form Subject)
```graphql theme={null}
mutation CreateAsset($input: CreateAssetInput!) {
createAsset(input: $input) {
asset {
id
displayName
properties
}
correlationId
errors {
message
type
}
}
}
```
**Variables:**
```json theme={null}
{
"input": {
"profile": "well-inspection",
"id": "well-abc-123",
"displayName": "Well ABC-123",
"properties": {
"operator": "ACME Energy",
"wellType": "gas",
"status": "active"
},
"geometry": {
"type": "Point",
"coordinates": [-114.0719, 51.0447]
}
}
}
```
## Issue Tracking
### List All Issues
```graphql theme={null}
query GetIssues($first: Int!, $filter: IssueFilter) {
issues {
all(first: $first, filter: $filter) {
edges {
node {
id
type
title
description
status
severity
openedAt
closedAt
dueAt
pastDue
assignee {
username
}
subject {
type
reference
}
trigger {
type
reference
}
}
}
pageInfo {
hasNextPage
endCursor
}
totalCount
}
}
}
```
**Variables (Filter Open Issues):**
```json theme={null}
{
"first": 20,
"filter": {
"status": ["OPEN", "IN_PROGRESS"]
}
}
```
### Get Specific Issue
```graphql theme={null}
query GetIssue($id: ID!) {
issues {
byId(id: $id) {
id
type
taskType
title
description
status
severity
openedAt
closedAt
dueAt
subject {
type
reference
}
assignee {
userId
username
}
annotations {
id
text
createdAt
createdBy {
username
}
attachments {
url
filename
contentType
}
}
xform {
formId
responseId
status
}
}
}
}
```
### Create Issue
```graphql theme={null}
mutation CreateIssue($input: CreateIssueInput!) {
createIssue(input: $input) {
issue {
id
title
status
type
}
correlationId
errors {
message
type
}
}
}
```
**Variables:**
```json theme={null}
{
"input": {
"title": "Quarterly Well Inspection - ABC-123",
"description": "Routine quarterly inspection required",
"type": "TASK",
"severity": "MEDIUM",
"dueAt": "2025-12-31T23:59:59Z",
"subject": {
"type": "ASSET",
"reference": "well-abc-123"
},
"assignee": {
"userId": "user-123"
}
}
}
```
### Update Issue Status
```graphql theme={null}
mutation UpdateIssue($input: UpdateIssueInput!) {
updateIssue(input: $input) {
issue {
id
status
closedAt
}
correlationId
errors {
message
type
}
}
}
```
**Variables:**
```json theme={null}
{
"input": {
"id": "issue-123",
"status": "RESOLVED"
}
}
```
### Add Annotation to Issue
```graphql theme={null}
mutation AddIssueAnnotation($input: AddIssueAnnotationInput!) {
addIssueAnnotation(input: $input) {
annotation {
id
text
createdAt
createdBy {
username
}
}
correlationId
errors {
message
type
}
}
}
```
**Variables:**
```json theme={null}
{
"input": {
"issueId": "issue-123",
"text": "Inspection completed. No issues found. Equipment operating normally.",
"attachments": [
{
"url": "https://storage.example.com/photos/inspection-photo.jpg",
"filename": "inspection-photo.jpg",
"contentType": "image/jpeg"
}
]
}
}
```
### Perform Follow-Up Action
Create or update a follow-up issue linked to an existing issue. The mutation finds an original issue using filters and creates a follow-up with the specified form data. Subsequent calls with the same `triggerContextReference` update the existing follow-up rather than creating duplicates.
```graphql theme={null}
mutation PerformIssueFollowUpAction($input: PerformIssueFollowUpActionInput!) {
performIssueFollowUpAction(input: $input) {
issue {
id
title
status
}
correlationId
}
}
```
**Variables:**
```json theme={null}
{
"input": {
"subjectFormReference": "leak",
"triggerContextReference": "external-id-123",
"filters": [
{
"field": "work_order_number",
"operator": "EQUAL",
"value": "external-id-123"
}
],
"followUpFormReference": "leak-repair",
"followUpTaskTitle": "Leak Repair Required",
"followUpTaskDescription": "Repair leak identified in work order external-id-123",
"followUpFormData": {
"technician_name": "John Smith",
"repairDate": "2025-01-01T00:00:00.000Z"
}
}
}
```
### Delete Issue
Deletes an issue. Assets and statuses associated with the issue are not affected.
```graphql theme={null}
mutation DeleteIssue($input: DeleteIssueInput!) {
deleteIssue(input: $input) {
issue {
id
title
}
correlationId
errors {
message
type
}
}
}
```
**Variables:**
```json theme={null}
{
"input": {
"issueId": "issue-123"
}
}
```
## Multi-Task Management
Multi-tasks enable coordinated campaigns across multiple locations or assets.
### Create Multi-Task
```graphql theme={null}
mutation CreateMultiTask($input: CreateIssueInput!) {
createIssue(input: $input) {
issue {
id
title
type
status
}
correlationId
errors {
message
type
}
}
}
```
**Variables:**
```json theme={null}
{
"input": {
"title": "Q4 2025 Site-Wide Inspection",
"description": "Quarterly inspection of all wells at North Field",
"type": "MULTITASK",
"severity": "HIGH",
"dueAt": "2025-12-31T23:59:59Z"
}
}
```
### Create Subtasks
```graphql theme={null}
mutation CreateSubtask($input: CreateIssueInput!) {
createIssue(input: $input) {
issue {
id
title
type
parentTask {
id
title
}
}
correlationId
errors {
message
type
}
}
}
```
**Variables:**
```json theme={null}
{
"input": {
"title": "Inspect Well ABC-123",
"type": "SUBTASK",
"parentTaskId": "multitask-456",
"subject": {
"type": "ASSET",
"reference": "well-abc-123"
},
"assignee": {
"userId": "field-tech-001"
}
}
}
```
### Query Multi-Task with Subtasks
```graphql theme={null}
query GetMultiTaskWithSubtasks($id: ID!) {
issues {
byId(id: $id) {
id
title
type
status
subtasks {
id
title
status
assignee {
username
}
subject {
type
reference
}
}
}
}
}
```
## XForms for Data Collection
### Query Available Forms
```graphql theme={null}
query GetForms {
forms {
all(first: 100) {
edges {
node {
formId
title
version
description
xformDetails {
model
binds {
nodeset
type
required
readonly
}
body {
... on XFormBodyControlNode {
id
control
label
hint
ref
}
... on XFormBodyGroupNode {
id
label
childNodeIds
}
}
}
}
}
}
}
}
```
### Get Specific Form
```graphql theme={null}
query GetForm($formId: ID!) {
forms {
byId(id: $formId) {
formId
title
version
description
xformDetails {
model
binds {
nodeset
type
required
relevant
constraint
calculate
}
body {
__typename
... on XFormBodyControlNode {
id
control
label
hint
items {
label
value
}
}
... on XFormBodyGroupNode {
id
label
childNodeIds
}
... on XFormBodyRepeatNode {
id
label
ref
childNodeIds
}
}
}
}
}
}
```
### Submit Form Response
```graphql theme={null}
mutation SubmitFormResponse($input: CreateFormResponseInput!) {
createFormResponse(input: $input) {
formResponse {
responseId
formId
submittedAt
submittedBy {
username
}
data
}
correlationId
errors {
message
type
}
}
}
```
**Variables:**
```json theme={null}
{
"input": {
"formId": "well-inspection-form",
"issueId": "issue-123",
"data": {
"inspector": "John Smith",
"inspectionDate": "2025-11-05",
"wellCondition": "good",
"pressureReading": "850",
"temperatureReading": "72",
"notes": "No issues observed",
"photos": [
"https://storage.example.com/photo1.jpg",
"https://storage.example.com/photo2.jpg"
]
}
}
}
```
### Link Form to Task
```graphql theme={null}
mutation LinkFormToTask($input: LinkFormToIssueInput!) {
linkFormToIssue(input: $input) {
issue {
id
xform {
formId
responseId
status
}
}
correlationId
errors {
message
type
}
}
}
```
**Variables:**
```json theme={null}
{
"input": {
"issueId": "issue-123",
"formId": "well-inspection-form"
}
}
```
## Workflows
### Query Workflow Definition
```graphql theme={null}
query GetWorkflow($workflowId: ID!) {
workflow(id: $workflowId) {
id
name
description
states {
id
name
isInitial
isFinal
}
transitions {
from
to
event
guards {
condition
message
}
}
}
}
```
### Trigger Workflow Transition
```graphql theme={null}
mutation TransitionIssue($input: TransitionIssueInput!) {
transitionIssue(input: $input) {
issue {
id
status
workflow {
currentState
availableTransitions {
event
to
}
}
}
correlationId
errors {
message
type
}
}
}
```
**Variables:**
```json theme={null}
{
"input": {
"issueId": "issue-123",
"event": "complete_inspection"
}
}
```
## Common Workflows
### Mobile Inspection Workflow
1. **Create Task** with asset subject and XForm
2. **Assign** to field technician
3. **Technician opens** task in mobile app
4. **Complete XForm** with inspection data
5. **Submit** form response
6. **Update task** status to RESOLVED
7. **Supervisor reviews** and CLOSES task
```javascript theme={null}
// Example mobile inspection flow
async function mobileInspectionWorkflow(assetId, formId, technicianId) {
// 1. Create task
const { data: taskData } = await createIssue({
title: `Inspect Asset ${assetId}`,
type: 'TASK',
subject: { type: 'ASSET', reference: assetId },
assignee: { userId: technicianId }
})
const taskId = taskData.createIssue.issue.id
// 2. Link form to task
await linkFormToIssue({
issueId: taskId,
formId: formId
})
// 3. Technician completes form
const formData = await collectDataInMobileApp()
// 4. Submit form response
await createFormResponse({
formId: formId,
issueId: taskId,
data: formData
})
// 5. Update task status
await updateIssue({
id: taskId,
status: 'RESOLVED'
})
return taskId
}
```
### Multi-Task Campaign Workflow
1. **Create multi-task** for campaign
2. **Generate subtasks** for each location
3. **Assign subtasks** to field teams
4. **Track completion** of individual subtasks
5. **Multi-task auto-completes** when all subtasks done
```javascript theme={null}
// Example multi-task campaign
async function createInspectionCampaign(assets, formId) {
// 1. Create multi-task
const { data: multiTaskData } = await createIssue({
title: 'Q4 Inspection Campaign',
type: 'MULTITASK',
dueAt: '2025-12-31T23:59:59Z'
})
const multiTaskId = multiTaskData.createIssue.issue.id
// 2. Create subtask for each asset
for (const asset of assets) {
await createIssue({
title: `Inspect ${asset.displayName}`,
type: 'SUBTASK',
parentTaskId: multiTaskId,
subject: { type: 'ASSET', reference: asset.id },
assignee: { userId: asset.assignedTech }
})
}
return multiTaskId
}
```
## Issue Templates
### Create Issue Template
```graphql theme={null}
mutation CreateIssueTemplate($input: CreateIssueTemplateInput!) {
createIssueTemplate(input: $input) {
template {
id
name
title
description
type
defaultSeverity
defaultFormId
}
correlationId
errors {
message
type
}
}
}
```
**Variables:**
```json theme={null}
{
"input": {
"name": "quarterly-well-inspection",
"title": "Quarterly Well Inspection",
"description": "Standard quarterly inspection procedure",
"type": "TASK",
"defaultSeverity": "MEDIUM",
"defaultFormId": "well-inspection-form"
}
}
```
### Create Issue from Template
```graphql theme={null}
mutation CreateIssueFromTemplate($input: CreateIssueFromTemplateInput!) {
createIssueFromTemplate(input: $input) {
issue {
id
title
type
xform {
formId
}
}
correlationId
errors {
message
type
}
}
}
```
**Variables:**
```json theme={null}
{
"input": {
"templateId": "quarterly-well-inspection",
"subject": {
"type": "ASSET",
"reference": "well-abc-123"
},
"assignee": {
"userId": "tech-001"
},
"dueAt": "2025-12-15T23:59:59Z"
}
}
```
## Asset Filters
Create reusable filters for finding form subjects:
### Create Asset Filter
```graphql theme={null}
mutation CreateAssetFilter($input: CreateAssetFilterInput!) {
createAssetFilter(input: $input) {
assetFilter {
id
displayName
profile
filterString
}
correlationId
errors {
message
type
}
}
}
```
**Variables:**
```json theme={null}
{
"input": {
"id": "active-wells-north-field",
"displayName": "Active Wells - North Field",
"profile": "well-inspection",
"subProfiles": [],
"filterString": "properties.status = 'active' AND properties.field = 'north'"
}
}
```
### Query Assets with Filter
```graphql theme={null}
query GetFilteredAssets($profile: ID!, $filterId: ID!) {
assets(profile: $profile) {
filtered(filter: $filterId, first: 100) {
edges {
node {
id
displayName
properties
}
}
}
}
}
```
## Best Practices
### 1. Use Asset Profiles for Form Subjects
Define asset profiles for entities that field teams will work on:
```graphql theme={null}
# Good - dedicated profile for inspection subjects
assetProfiles { byId(profile: "equipment-inspection") }
# Avoid - mixing operational assets with form subjects
# Use CAM assets for operational data, FSM asset profiles for forms
```
### 2. Link Forms to Tasks
Always link XForms to tasks for proper tracking:
```graphql theme={null}
# Good - form linked to task
linkFormToIssue(input: { issueId: "task-123", formId: "inspection-form" })
# Incomplete - orphaned form response
createFormResponse(input: { formId: "inspection-form", data: {...} })
```
### 3. Use Multi-Tasks for Campaigns
For coordinated work across multiple locations, use multi-tasks:
```graphql theme={null}
# Good - multi-task with subtasks
createIssue(type: "MULTITASK") → createIssue(type: "SUBTASK", parentTaskId: "...")
# Less organized - individual unrelated tasks
createIssue(type: "TASK") + createIssue(type: "TASK") + ...
```
### 4. Leverage Templates
Create templates for recurring workflows:
```graphql theme={null}
# Good - consistent task creation
createIssueFromTemplate(templateId: "monthly-inspection")
# More work - manual task creation each time
createIssue(title: "...", description: "...", formId: "...")
```
### 5. Filter by Status for Work Queues
Query issues by status to create work queues:
```graphql theme={null}
# Active work queue
issues { all(filter: { status: ["OPEN", "IN_PROGRESS"] }) }
# Completed work
issues { all(filter: { status: ["RESOLVED", "CLOSED"] }) }
```
## Error Handling
FSM mutations return errors in the standard format:
```json theme={null}
{
"data": {
"createIssue": {
"issue": null,
"correlationId": "abc-123",
"errors": [
{
"message": "Subject asset 'well-xyz' not found",
"type": "INVALID_SUBJECT"
}
]
}
}
}
```
Common error types:
* `INVALID_SUBJECT`: Referenced subject does not exist
* `INVALID_ASSIGNEE`: Assignee user not found
* `INVALID_FORM`: Form ID does not exist
* `INVALID_STATUS_TRANSITION`: Status change not allowed
* `MISSING_REQUIRED`: Required field not provided
* `DUPLICATE_ID`: ID already exists
## Related Resources
* **[Issues Subgraph Reference](../subgraphs/issues)** - Complete issue schema
* **[Workflow Subgraph Reference](../subgraphs/workflow)** - Workflow definitions
* **[Forms Subgraph Reference](../subgraphs/forms)** - XForms schema
* **[Assets Subgraph Reference](../subgraphs/assets)** - Asset profiles schema
* **[CAM Guide](./cam-assets)** - Connected asset management (different from FSM assets)
* **[Common Patterns](../common-patterns)** - Pagination and filtering
# GraphQL API Overview
Source: https://docs.sensorup.com/api/graphql/overview
Introduction to the SensorUp federated GraphQL API, architecture, and available endpoints across multiple environments.
# GraphQL API Overview
The SensorUp platform provides a comprehensive GraphQL API built on Apollo Federation, allowing you to query and manipulate data across assets, emissions, issues, workflows, and more through a unified graph interface.
## Architecture
The SensorUp GraphQL API uses **Apollo Federation v2.3** to compose 15 specialized subgraphs into a single, unified API. This architecture enables:
* **Domain separation**: Each subgraph owns a specific business domain
* **Independent deployment**: Subgraphs can be updated independently
* **Type composition**: Entities can be extended across multiple subgraphs
* **Optimized queries**: The gateway intelligently routes and batches requests
### Subgraphs by Domain
| Domain | Subgraphs | Purpose |
| - | - | - |
| **Connected Asset Management (CAM)** | su-cam-assets | Asset types, properties, and hierarchy for connected operations |
| **Field Service Management** | su-assets, su-issues, su-workflow, su-forms | Form subjects for mobile workflows, issue tracking, workflow orchestration |
| **Emissions/LDAR** | su-methane-ldar-backend, su-methane-reconcile-backend, su-detections-ingress | LDAR operations, reconciliation, detection ingestion |
| **Core Platform** | su-backend, su-auth, su-user, su-maps, su-catalog, su-eventhub | Authentication, user management, geospatial services, catalogs, events, core infrastructure |
| **Deprecated** | su-sites | Site management (deprecated - use su-maps for geospatial features) |
## Available Environments
The GraphQL API is available in multiple environments:
| Environment | Gateway URL | Purpose |
| - | - | - |
| **Demo** | `https://customer-demo.sensorup.com/api/graphql` | Demo and POC environment |
| **Staging** | Contact your account team | Pre-production testing |
| **Production** | Contact your account team | Production workloads |
Staging and production URLs are tenant-specific. Contact your SensorUp account team for your organization's endpoints.
## API Capabilities
### Queries
* Asset management and profiles
* Emission observations and LDAR workflows
* Issue tracking and templates
* Site and geospatial data
* User and authentication information
* Workflow definitions and tasks
* Dynamic forms and catalogs
### Mutations
* Create and update assets
* Manage emission events and observations
* Create and modify issues
* Update workflow states
* User authentication and session management
* Configure asset profiles and views
### Common Features
* **Relay-style pagination**: Cursor-based pagination with `edges`, `nodes`, and `PageInfo`
* **GeoJSON support**: Full GeoJSON type system for geospatial data
* **Audit trails**: Automatic tracking of creation and modification metadata
* **Error handling**: Consistent `MutationError` interface across all mutations
* **Entity references**: Cross-subgraph entity resolution via Apollo Federation
## Getting Started
1. **[Quickstart Guide](./quickstart)** - Make your first GraphQL query
2. **[Authentication](./authentication)** - Learn how to authenticate API requests
3. **[Common Patterns](./common-patterns)** - Understand pagination, filtering, and error handling
4. **[Domain Guides](./guides/cam-assets)** - Explore specific use cases by domain:
* [Connected Asset Management](./guides/cam-assets) - Asset types, properties, and hierarchy
* [Field Service Management](./guides/field-service) - Mobile workflows and issue tracking
* [Emissions & LDAR](./guides/emissions) - Methane detection and compliance
* [Core Platform](./guides/core-platform) - Authentication, maps, and infrastructure
## GraphQL Tools
You can interact with the API using:
* **Apollo Explorer** (Recommended): Built-in interactive explorer available as an application plugin
* Demo environment: `https://customer-demo.sensorup.com/plugins/sr/apolloGraphql`
* Authentication handled automatically when accessed within the application
* Full schema documentation, query building, and testing capabilities
* **Apollo Studio**: View the federated schema and query planning (requires credentials)
* Access at: [https://studio.apollographql.com/graph/su-graphql-t912yf/](https://studio.apollographql.com/graph/su-graphql-t912yf/)
* **HTTP Clients**: Any GraphQL client library (Apollo Client, urql, graphql-request, etc.)
* **curl**: Direct HTTP requests to the gateway endpoint
## Schema Reference
For detailed type definitions and technical reference:
* **[Subgraph Reference](./subgraphs/assets)** - Full schema documentation for each subgraph
* **[Raw SDL Files](./schemas/sdl/)** - GraphQL schema definition language files
* **[Federation Concepts](./federation)** - Understanding entity composition across subgraphs
## Support
Need help with the GraphQL API?
* Review the [Domain Guides](./guides/cam-assets) for common use cases
* Check the [Common Patterns](./common-patterns) for best practices
* Contact your SensorUp account team for technical support
# Performance & Best Practices
Source: https://docs.sensorup.com/api/graphql/performance
Learn how to optimize GraphQL queries, improve performance, and follow best practices for the SensorUp API.
# Performance & Best Practices
This guide covers strategies for optimizing your use of the SensorUp GraphQL API to achieve the best performance and reliability.
## Query Optimization
### Request Only What You Need
GraphQL's strength is precise field selection. Use it:
**Bad:**
```graphql theme={null}
query {
assets {
all(first: 100) {
edges {
node {
id
profile
displayName
secondaryDisplayName
modifiedAt
geometry { type coordinates bbox }
properties # Potentially large!
observation # Very large!
geoJSONFeature # Redundant with above
related # Expensive!
}
}
}
}
}
```
**Good:**
```graphql theme={null}
query {
assets {
all(first: 100) {
edges {
node {
id
displayName
modifiedAt
}
}
}
}
}
```
**Impact**: Reduced payload size by 90%+, faster response times
### Use Pagination Appropriately
Don't request more data than you can display:
**Bad:**
```graphql theme={null}
query {
assets {
all(first: 10000) { # Too many!
edges {
node {
id
displayName
}
}
}
}
}
```
**Good:**
```graphql theme={null}
query {
assets {
all(first: 20) { # One page
edges {
node {
id
displayName
}
}
pageInfo {
hasNextPage
endCursor
}
}
}
}
```
**Recommended page sizes**:
* UI lists: 20-50 items
* Background processing: 100-500 items
* Exports: Use export endpoints, not pagination
### Batch Related Queries
GraphQL allows querying multiple resources in one request:
**Bad:**
```javascript theme={null}
// 3 separate requests
const session = await getSession()
const assets = await getAssets()
const issues = await getIssues()
```
**Good:**
```javascript theme={null}
// 1 request
const result = await query(`
query {
session {
username
authenticated
}
assetProfiles {
all(first: 20) {
edges {
node {
profile
title
}
}
}
}
issues {
all(first: 20) {
edges {
node {
id
title
}
}
}
}
}
`)
```
**Impact**: Reduced latency by \~66%, fewer round trips
### Use Fragments for Reusability
Define reusable fragments for common field sets:
```graphql theme={null}
fragment AssetSummary on Asset {
id
displayName
modifiedAt
geometry {
type
coordinates
}
}
fragment IssueSummary on Issue {
id
title
status
severity
dueAt
}
query GetData {
assets {
all(first: 20) {
edges {
node {
...AssetSummary
}
}
}
}
issues {
all(first: 20) {
edges {
node {
...IssueSummary
}
}
}
}
}
```
## Federation Performance
### Understand Query Plans
Cross-subgraph queries require multiple fetches. Minimize hops:
**Less Efficient:**
```graphql theme={null}
query {
issues {
all(first: 100) {
edges {
node {
subject {
assetReference { # Fetch from su-assets (100 times)
asset {
displayName
assetProfile { # Another fetch (100 times)
title
}
}
}
}
}
}
}
}
}
```
**More Efficient:**
```graphql theme={null}
query {
issues {
all(first: 100) {
edges {
node {
id
title
status
}
}
}
}
}
// If you need asset details, fetch them separately with specific IDs
```
### Leverage Parallel Execution
Federation executes independent root fields in parallel:
```graphql theme={null}
query {
session { # su-auth - parallel
username
}
assetProfiles { # su-assets - parallel
all(first: 10) {
edges {
node {
title
}
}
}
}
issues { # su-issues - parallel
all(first: 10) {
edges {
node {
title
}
}
}
}
}
```
All three subgraphs are queried simultaneously.
## Filtering & Searching
### Use Server-Side Filtering
Filter on the server, not the client:
**Bad:**
```javascript theme={null}
// Fetch everything, filter client-side
const all = await getAssets({ first: 1000 })
const filtered = all.filter(a => a.modifiedAt > cutoff)
```
**Good:**
```javascript theme={null}
// Filter server-side
const filtered = await getAssets({
first: 100,
filter: { modifiedAfter: cutoff }
})
```
### Specific Lookups vs. List Filtering
Use ID lookups when you know the ID:
**Less Efficient:**
```graphql theme={null}
query {
assets {
all(first: 1000, filter: { id: "asset-123" }) {
edges {
node {
id
displayName
}
}
}
}
}
```
**More Efficient:**
```graphql theme={null}
query {
assetProfiles {
byId(profile: "wells") {
assetById(id: "asset-123") {
id
displayName
}
}
}
}
```
## Caching Strategies
### Cache Static Data
Some data changes infrequently:
| Data Type | Change Frequency | Cache Duration |
| - | - | - |
| Asset Profiles | Rarely | 1 hour - 1 day |
| Catalog Entries | Rarely | 1 day - 1 week |
| Form Templates | Occasionally | 1 hour |
| Map Configurations | Rarely | 1 day |
| User Session | Often | No cache (always fetch) |
| Assets | Often | No cache or short (5 min) |
### HTTP Caching
Configure appropriate cache headers:
```javascript theme={null}
const response = await fetch(url, {
headers: {
'Cache-Control': 'max-age=300' // 5 minutes
}
})
```
### Application-Level Caching
Use a caching client like Apollo Client:
```javascript theme={null}
import { ApolloClient, InMemoryCache } from '@apollo/client'
const client = new ApolloClient({
uri: 'https://customer-demo.sensorup.com/api/graphql',
cache: new InMemoryCache({
typePolicies: {
AssetProfile: {
keyFields: ['profile']
},
Asset: {
keyFields: ['profile', 'id']
}
}
})
})
```
## Rate Limiting & Throttling
### Implement Exponential Backoff
When encountering rate limits or errors:
```javascript theme={null}
async function fetchWithRetry(query, maxRetries = 3) {
for (let i = 0; i < maxRetries; i++) {
try {
return await fetch(query)
} catch (error) {
if (i === maxRetries - 1) throw error
const delay = Math.min(1000 * Math.pow(2, i), 10000)
await new Promise(resolve => setTimeout(resolve, delay))
}
}
}
```
### Batch Updates
Instead of many small mutations, batch when possible:
**Less Efficient:**
```javascript theme={null}
for (const issue of issues) {
await updateIssue(issue.id, { status: 'CLOSED' })
}
```
**More Efficient:**
```javascript theme={null}
await bulkUpdateIssues({
filter: { issueIds: issues.map(i => i.id) },
updates: { status: 'CLOSED' }
})
```
## Query Complexity
### Avoid Deep Nesting
Deep queries can be expensive:
**High Complexity:**
```graphql theme={null}
query {
sites {
all {
assets {
all {
issueSubject {
issues {
all {
annotations {
all {
# Very expensive!
}
}
}
}
}
}
}
}
}
}
```
**Lower Complexity:**
```graphql theme={null}
query {
sites {
all(first: 20) {
edges {
node {
id
name
}
}
}
}
}
# Then fetch assets for specific sites
# Then fetch issues for specific assets
```
### Limit List Sizes
Always use pagination limits:
```graphql theme={null}
query {
assets {
all(first: 20) { # Always specify!
edges {
node {
id
}
}
}
}
}
```
## Monitoring & Debugging
### Use Correlation IDs
Include correlation IDs for tracking:
```javascript theme={null}
const correlationId = uuid()
await mutation({
variables: {
input: { ... },
correlationId
}
})
console.log(`Request ID: ${correlationId}`)
```
### Log Query Performance
Track slow queries:
```javascript theme={null}
const start = Date.now()
const result = await client.query({ query })
const duration = Date.now() - start
if (duration > 1000) {
console.warn(`Slow query: ${duration}ms`, query)
}
```
### Monitor Error Rates
Track and alert on error patterns:
```javascript theme={null}
let errorCount = 0
let requestCount = 0
try {
await query()
requestCount++
} catch (error) {
errorCount++
requestCount++
const errorRate = errorCount / requestCount
if (errorRate > 0.05) {
alert('High error rate detected!')
}
}
```
## Network Optimization
### Use Compression
Enable gzip/brotli compression:
```javascript theme={null}
fetch(url, {
headers: {
'Accept-Encoding': 'gzip, deflate, br'
}
})
```
### Minimize Payload Size
* Use fragments to avoid duplication
* Omit `__typename` if not needed
* Use aliases to simplify response structure
### Connection Pooling
Reuse HTTP connections:
```javascript theme={null}
const agent = new http.Agent({
keepAlive: true,
maxSockets: 50
})
fetch(url, { agent })
```
## Best Practices Checklist
### Query Design
* [ ] Request only needed fields
* [ ] Use pagination (first: 20-100)
* [ ] Apply server-side filters
* [ ] Use specific lookups vs. list queries
* [ ] Batch related queries in one request
* [ ] Use fragments for reusability
### Performance
* [ ] Cache static data (profiles, catalogs)
* [ ] Implement exponential backoff
* [ ] Monitor query performance
* [ ] Use correlation IDs
* [ ] Minimize cross-subgraph hops
* [ ] Limit query depth (≤ 4 levels)
### Error Handling
* [ ] Check GraphQL-level errors
* [ ] Check mutation-level errors
* [ ] Log errors with context
* [ ] Implement retry logic
* [ ] Handle partial failures gracefully
### Security
* [ ] Store credentials securely
* [ ] Rotate API keys regularly
* [ ] Use HTTPS always
* [ ] Validate input data
* [ ] Sanitize user-provided content
## Performance Metrics
### Target Metrics
| Metric | Target | Good | Needs Improvement |
| - | - | - | - |
| Query latency (p50) | \< 200ms | \< 500ms | > 500ms |
| Query latency (p99) | \< 1s | \< 2s | > 2s |
| Error rate | \< 0.1% | \< 1% | > 1% |
| Cache hit rate | > 80% | > 60% | \< 60% |
### Measuring Performance
```javascript theme={null}
const metrics = {
queryCount: 0,
errorCount: 0,
totalDuration: 0,
cacheHits: 0
}
function recordQuery(duration, fromCache, error) {
metrics.queryCount++
metrics.totalDuration += duration
if (fromCache) metrics.cacheHits++
if (error) metrics.errorCount++
}
function getMetrics() {
return {
avgDuration: metrics.totalDuration / metrics.queryCount,
errorRate: metrics.errorCount / metrics.queryCount,
cacheHitRate: metrics.cacheHits / metrics.queryCount
}
}
```
## Common Anti-Patterns
### 1. Over-fetching
```graphql theme={null}
# Don't fetch everything "just in case"
query {
assets {
all(first: 100) {
edges {
node {
# Every possible field...
}
}
}
}
}
```
### 2. N+1 in Application Code
```javascript theme={null}
// Don't do this!
const issues = await getIssues()
for (const issue of issues) {
const asset = await getAsset(issue.assetId) // N queries!
}
```
### 3. Polling Too Frequently
```javascript theme={null}
// Don't poll every second!
setInterval(async () => {
await fetchData()
}, 1000)
// Use reasonable intervals
setInterval(async () => {
await fetchData()
}, 30000) // 30 seconds
```
### 4. Ignoring Errors
```javascript theme={null}
// Don't ignore errors!
try {
await mutation()
} catch (e) {
// Silence!
}
// Handle them properly
try {
await mutation()
} catch (error) {
console.error('Mutation failed:', error)
showErrorToUser(error.message)
reportToMonitoring(error)
}
```
## Resources
* **[Federation Concepts](./federation)** - Understanding query planning
* **[Common Patterns](./common-patterns)** - API patterns and conventions
* **[Apollo Client Performance](https://www.apollographql.com/docs/react/performance/performance/)** - Client-side optimization
* **[GraphQL Best Practices](https://graphql.org/learn/best-practices/)** - General GraphQL guidelines
## Support
For performance issues or optimization assistance:
* Review query plans in Apollo Studio
* Contact your SensorUp account team
* Provide correlation IDs for specific slow queries
# GraphQL API Quickstart
Source: https://docs.sensorup.com/api/graphql/quickstart
Get started with the SensorUp GraphQL API - make your first query and learn the basics.
# GraphQL API Quickstart
This guide will help you make your first GraphQL query to the SensorUp API and understand the basics of working with the federated graph.
## Prerequisites
Before you begin, you'll need:
* Access to a SensorUp environment (demo, staging, or production)
* Valid authentication credentials (see [Authentication](./authentication))
* A GraphQL client or HTTP tool (curl, Postman, or a programming language client)
## Your First Query
### Using curl
```bash theme={null}
curl -X POST https://customer-demo.sensorup.com/api/graphql \
-H "Content-Type: application/json" \
-H "x-sensorup-sessionid: YOUR_SESSION_ID" \
-d '{
"query": "query { session { username authenticated } }"
}'
```
### Response
```json theme={null}
{
"data": {
"session": {
"username": "your-username",
"authenticated": true
}
}
}
```
## Understanding the Query Structure
GraphQL queries have three main components:
```graphql theme={null}
query { # Operation type (query, mutation, or subscription)
session { # Root field - what you're querying
username # Selection - fields you want returned
authenticated
}
}
```
## Common Query Patterns
### Querying Asset Profiles
```graphql theme={null}
query GetAssetProfiles {
assetProfiles {
all(first: 10) {
edges {
node {
profile
title
displayNameProperty
}
}
pageInfo {
hasNextPage
endCursor
}
}
}
}
```
### Getting Specific Asset by ID
```graphql theme={null}
query GetAsset($profileId: ID!, $assetId: ID!) {
assetProfiles {
byId(profile: $profileId) {
profile
title
assetById(id: $assetId) {
id
displayName
properties
geometry
}
}
}
}
```
**Variables:**
```json theme={null}
{
"profileId": "your-profile-id",
"assetId": "your-asset-id"
}
```
### Querying Issues
```graphql theme={null}
query GetIssues {
issues {
all(first: 10) {
edges {
node {
id
displayName
status
createdAt
audit {
createdBy {
userId
}
}
}
}
}
}
}
```
## Making Mutations
Mutations modify data on the server. All mutations follow a consistent pattern with result types that include `correlationId` and `errors`.
### Creating an Asset Filter
```graphql theme={null}
mutation CreateAssetFilter($input: CreateAssetFilterInput!) {
createAssetFilter(input: $input) {
assetFilter {
id
displayName
profile
}
correlationId
errors {
message
type
}
}
}
```
**Variables:**
```json theme={null}
{
"input": {
"id": "my-filter-id",
"displayName": "My Asset Filter",
"profile": "asset-profile-id",
"subProfiles": []
}
}
```
## Pagination
The API uses Relay-style cursor-based pagination:
```graphql theme={null}
query PaginatedAssets($first: Int!, $after: String) {
assetProfiles {
byId(profile: "your-profile") {
assets(first: $first, after: $after) {
edges {
node {
id
displayName
}
}
pageInfo {
hasNextPage
hasPreviousPage
startCursor
endCursor
}
}
}
}
}
```
**First page:**
```json theme={null}
{ "first": 10 }
```
**Next page:**
```json theme={null}
{ "first": 10, "after": "cursor-from-previous-page" }
```
## Error Handling
### Query Errors
GraphQL returns errors in the `errors` array:
```json theme={null}
{
"errors": [
{
"message": "Cannot query field 'invalidField' on type 'Asset'",
"locations": [{ "line": 3, "column": 5 }]
}
]
}
```
### Mutation Errors
Mutations return errors in the result type:
```json theme={null}
{
"data": {
"createAssetFilter": {
"assetFilter": null,
"correlationId": "abc-123",
"errors": [
{
"message": "Asset filter with this ID already exists",
"type": "DUPLICATE_ID"
}
]
}
}
}
```
## Using GraphQL Clients
### JavaScript/TypeScript
```javascript theme={null}
// Using graphql-request
import { request, gql } from 'graphql-request'
const query = gql`
query {
session {
username
authenticated
}
}
`
const data = await request(
'https://customer-demo.sensorup.com/api/graphql',
query,
{},
{ 'x-sensorup-sessionid': sessionId }
)
```
### Python
```python theme={null}
# Using gql
from gql import gql, Client
from gql.transport.requests import RequestsHTTPTransport
transport = RequestsHTTPTransport(
url='https://customer-demo.sensorup.com/api/graphql',
headers={'x-sensorup-sessionid': session_id}
)
client = Client(transport=transport, fetch_schema_from_transport=True)
query = gql("""
query {
session {
username
authenticated
}
}
""")
result = client.execute(query)
```
## Next Steps
Now that you've made your first queries:
1. **[Authentication](./authentication)** - Learn about auth methods and credential management
2. **[Common Patterns](./common-patterns)** - Deep dive into pagination, filtering, and GeoJSON
3. **Domain Guides** - Explore specific use cases:
* [Assets](./guides/cam-assets) - Asset management
* [Field Service Management](./guides/field-service) - Issues, workflows, and mobile tasks
* [Emissions](./guides/emissions) - LDAR operations
* [Core Platform](./guides/core-platform) - Authentication, users, and platform services
4. **Subgraph Reference** - Complete schema documentation:
* [Assets](./subgraphs/assets) - Asset profiles for field service
* [CAM Assets](./subgraphs/cam-assets) - Connected asset management
* [Issues](./subgraphs/issues) - Issue tracking
* [Forms](./subgraphs/forms) - XForms data collection
* [Auth](./subgraphs/auth) - Authentication and sessions
* [Workflow](./subgraphs/workflow) - Workflow definitions
* And more in the subgraphs directory
## Interactive Exploration
### Apollo Explorer (Recommended)
SensorUp includes Apollo Explorer as a built-in plugin for interactive query building and schema exploration:
**Demo Environment:**
```
https://customer-demo.sensorup.com/plugins/sr/apolloGraphql
```
**Features:**
* Interactive query builder with autocomplete
* Full schema documentation browser
* Query history and saved queries
* Authentication handled automatically (no need to manually set headers)
* Real-time query validation
**For other environments:**
* Replace `customer-demo.sensorup.com` with your environment's hostname
* The plugin path remains `/plugins/sr/apolloGraphql`
### Additional Resources
For further exploration tools, contact your SensorUp account team about:
* Apollo Studio access for advanced query planning and performance monitoring
* Postman collections with example queries
# Assets Subgraph Reference
Source: https://docs.sensorup.com/api/graphql/subgraphs/assets
Technical reference for the su-assets subgraph schema, types, queries, and mutations.
# Assets Subgraph Reference
The `su-assets` subgraph provides comprehensive asset management capabilities including asset profiles, properties, relationships, and views.
## Subgraph Information
* **Name**: `su-assets`
* **Routing URL**: `https://73qfchk50k.execute-api.us-west-2.amazonaws.com/poc/graphql`
* **Last Updated**: 2025-10-09
* **SDL**: [View Schema](../schemas/sdl/su-assets.graphql)
## Overview
This subgraph owns:
* Asset profiles and their configuration
* Individual assets and their properties
* Asset relationships and hierarchies
* View configurations for UI rendering
* Asset filters for workflow integration
* Asset conversion configurations
## Root Types
### Query Fields
```graphql theme={null}
extend type Query {
assetProfiles: AssetProfiles
assets(profile: ID!): Assets
assetFilters: [AssetSelectionFilter!]
assetFilter(id: ID!): AssetSelectionFilter
assetFilterDownloads: [AssetDownload!]
}
```
### Mutation Fields
```graphql theme={null}
extend type Mutation {
updateAssetProfile(input: UpdateAssetProfileInput): AssetProfileMutationResult
putAssetProfileExtension(input: putAssetProfileExtensionInput!): AssetProfileMutationResult
removeAssetProfileExtension(input: removeAssetProfileExtensionInput!): AssetProfileMutationResult
updateAssetProfileViewConfiguration(input: UpdateAssetProfileViewConfigurationInput!): AssetProfileViewConfigurationMutationResult!
updateAssetProfileViewLayout(input: UpdateAssetProfileViewLayoutInput): AssetProfileViewLayoutMutationResult!
updateAssetProfileAssetConversionConfiguration(input: UpdateAssetProfileAssetConversionConfigurationInput!): AssetProfileAssetConversionConfigurationMutationResult!
createAssetFilter(input: CreateAssetFilterInput!, correlationId: String): AssetFilterMutationResult
updateAssetFilter(input: UpdateAssetFilterInput!, correlationId: String): AssetFilterMutationResult
}
```
## Core Types
### AssetProfile
Defines the structure and behavior of a class of assets.
```graphql theme={null}
type AssetProfile @key(fields: "profile") {
profile: ID!
title: String!
owner: EntityOwner!
properties: [AssetPropertyDefinition!]
propertyMaps: [AssetProfilePropertyMapping!]
displayNameProperty: String!
displayNameTemplate: String
secondaryDisplayNameProperty: String
isDeletedProperty: String
forceAssetStateUpdates: Boolean
relationships: [AssetProfileRelationship!]
assets(first: Int, after: String, filter: AssetFilter): AssetsConnection
assetsExport(...): AssetProfileAssetExport
assetById(id: ID!): Asset
upDatasets: [UpDataset!]
upDataset(dataset: String!): UpDataset
viewConfigurations: [AssetProfileViewConfiguration!]
viewConfiguration(id: ID!): AssetProfileViewConfiguration
assetConversionConfigurations: [AssetProfileAssetConversionConfiguration!]
stateUpdateDatasets: [StateUpdateDataset!]
}
```
**Key Fields:**
* `profile`: Unique identifier for this asset profile type
* `title`: Human-readable name
* `displayNameProperty`: Property used for asset display name
* `properties`: Effective properties available on assets
* `relationships`: Defined relationships to other asset profiles
### Asset
Individual asset instance.
```graphql theme={null}
type Asset @key(fields: "profile id") {
id: ID!
profile: ID!
assetProfile: AssetProfile
modifiedAt: DateTime
geometry: GeoJSONGeometryInterface
properties(only: [String!]): JSONObject
observation: JSONObject
geoJSONFeature: GeoJSONFeature
displayName: String!
secondaryDisplayName: String
related(relationship: ID, params: JSONObject): AssetRelationship
issueSubject: IssueSubject!
isDeleted: Boolean!
}
```
**Key Fields:**
* `id`: Unique asset identifier within profile
* `profile`: Reference to asset profile
* `displayName`: Computed display name from profile configuration
* `properties`: Dynamic properties from underlying datasets
* `observation`: Merged state observation
* `geometry`: GeoJSON geometry if geospatial
* `related`: Navigate relationships to other assets
### AssetRelationship
Union type for one-to-one or one-to-many relationships.
```graphql theme={null}
union AssetRelationship = AssetRelationshipOne | AssetRelationshipMany
type AssetRelationshipOne {
asset: Asset
observation: JSONObject
}
type AssetRelationshipMany {
assets: [Asset!]
observations: [JSONObject!]
}
```
### AssetProfileRelationship
Defines a relationship between asset profiles.
```graphql theme={null}
type AssetProfileRelationship {
relationship: ID!
type: AssetProfileRelationshipType! # ONE or MANY
profile: ID!
assetProfile: AssetProfile!
referenceProperty: String
referenceType: AssetProfileRelationshipReferenceType!
lookupProperty: String
lookupType: AssetProfileRelationshipReferenceType!
parameters: [UpSpecificationParameter!]
}
```
## Pagination
Uses Relay-style cursor pagination:
```graphql theme={null}
type AssetsConnection {
pageInfo: PageInfo!
edges: [AssetEdge]
}
type AssetEdge {
node: Asset
}
```
## View Configurations
UI layout and visualization settings:
```graphql theme={null}
type AssetProfileViewConfiguration {
id: ID!
name: String
map: AssetProfileViewMap
layouts(mediaTypes: [AssetProfileViewLayoutMediaType!]): [AssetProfileViewLayout!]
}
type AssetProfileViewLayout {
mediaType: AssetProfileViewLayoutMediaType # WEB, MOBILE, PRINTABLE
widgets: [AssetProfileViewWidget!]
}
type AssetProfileViewWidget {
id: ID!
layout: AssetProfileViewLayoutDetails! # x, y, w, h
name: String!
settings: JSONObject!
widget: String!
}
```
## Asset Filters
Reusable asset selections for workflows:
```graphql theme={null}
type AssetSelectionFilter @key(fields: "id") {
id: ID!
displayName: String!
description: String
profile: ID!
assetProfile: AssetProfile!
subProfiles: [AssetSelectionFilterRelationship!]
audit: AssetSelectionFilterAudit
}
```
## Entity Extensions
This subgraph extends entities from other subgraphs:
### EntityOwner
```graphql theme={null}
type EntityOwner
@extends
@key(fields: "username group") {
username: String! @external
group: String! @external
}
```
### IssueSubject
```graphql theme={null}
type IssueSubject
@extends
@key(fields: "type reference") {
type: String! @external
reference: ID! @external
assetReference: AssetReference @requires(fields: "type reference")
}
```
## Common Patterns
### Query Assets with Pagination
```graphql theme={null}
query GetAssets($profile: ID!, $first: Int!, $after: String) {
assetProfiles {
byId(profile: $profile) {
assets(first: $first, after: $after) {
edges {
node {
id
displayName
modifiedAt
}
}
pageInfo {
hasNextPage
endCursor
}
}
}
}
}
```
### Update Asset Profile
```graphql theme={null}
mutation UpdateProfile($input: UpdateAssetProfileInput!) {
updateAssetProfile(input: $input) {
assetProfile {
profile
displayNameTemplate
}
correlationId
errors {
message
type
}
}
}
```
### Export Assets
```graphql theme={null}
query ExportAssets($profile: ID!) {
assetProfiles {
byId(profile: $profile) {
assetsExport(
properties: ["name", "status"],
isExcel: false
) {
csvFileDownloadUrl(exportName: "assets")
}
}
}
}
```
## Related Resources
* **[CAM Assets Subgraph](./cam-assets)** - Camera-specific assets
* **[Full SDL Schema](../schemas/sdl/su-assets.graphql)** - Complete type definitions
## Type Index
Key types defined in this subgraph:
* `AssetProfile` - Profile definitions
* `Asset` - Individual assets
* `AssetPropertyDefinition` - Property schemas
* `AssetRelationship` - Relationship data
* `AssetProfileViewConfiguration` - UI configurations
* `AssetSelectionFilter` - Reusable filters
* `PageInfo` - Pagination metadata (@shareable)
* GeoJSON types (@shareable)
# Auth Subgraph Reference
Source: https://docs.sensorup.com/api/graphql/subgraphs/auth
Technical reference for the su-auth subgraph providing authentication and authorization.
# Auth Subgraph Reference
The `su-auth` subgraph provides authentication, authorization, and session management capabilities.
## Subgraph Information
* **Name**: `su-auth`
* **Routing URL**: `https://xu558bs6wi.execute-api.us-west-2.amazonaws.com/poc/graphql`
* **Last Updated**: 2025-08-15
* **SDL**: [View Schema](../schemas/sdl/su-auth.graphql)
## Overview
This subgraph owns:
* User authentication (sign in/out)
* Session management
* Multi-factor authentication (MFA)
* API key generation
* AWS credentials provisioning
* Device management
## Root Query Fields
```graphql theme={null}
extend type Query {
session: AuthSession
credentials(group: String): AuthCredentials
config: Config
signWorkatoJwtToken(customerVendorOrigin: String): String
}
```
## Root Mutation Fields
```graphql theme={null}
extend type Mutation {
signIn(input: AuthSignInInput!): AuthMutationResult!
signOut: AuthMutationResult
globalSignOut: AuthMutationResult
forgotPassword(input: AuthForgotPasswordInput): AuthMutationResult
forgotPasswordSubmit(input: AuthForgotPasswordSubmitInput): AuthMutationResult
completeNewPassword(input: AuthCompleteNewPasswordInput): AuthMutationResult!
federatedSignIn(input: AuthFederatedSignInInput!): AuthMutationResult
confirmSignIn(input: AuthConfirmSignInInput): AuthConfirmSignInResult!
setupTOTP: AuthTOTPMutationResult!
verifyTOTPToken(input: AuthVerifyTOTPTokenInput): AuthMutationResult
setSessionUserGroup(input: AuthSetSessionUserGroupInput): AuthMutationResult
createAPIKey(input: AuthCreateAPIKeyInput!): AuthAPIKeyResult!
reauthenticate(input: ReauthenticationInput!): AuthMutationResult!
forgetDevices(input: AuthForgetSpecificDevicesInput): AuthMutationResult
completeAuthChallenge(input: CompleteAuthChallengeInput!): CompleteAuthChallengeResult!
generateSMSCode: AuthMutationResult
verifySMSCode(input: AuthVerifySMSCodeInput): AuthMutationResult
}
```
## Core Types
### AuthSession
Current authentication session information.
```graphql theme={null}
type AuthSession @key(fields: "username") {
username: ID!
preferredMFA: AuthMFAType
attributes: AuthAttributes
challengeName: AuthChallengeType
authenticated: Boolean!
audit: Audit!
expiresAt: DateTime!
expiresAtHard: DateTime!
userGroup: ID!
publicReference: ID!
lastAuthenticatedAt: DateTime
}
```
### AuthCredentials
Temporary AWS credentials for accessing AWS services.
```graphql theme={null}
type AuthCredentials {
accessKeyId: String!
secretAccessKey: String!
sessionToken: String!
expiration: DateTime!
}
```
### AuthDevice
Registered device information.
```graphql theme={null}
type AuthDevice {
deviceKey: ID!
name: String
remembered: Boolean
createdAt: DateTime
modifiedAt: DateTime
lastSignedInAt: DateTime
lastIpAddress: String
}
```
## Entity Extensions
### User
Extends User type from su-user with device information.
```graphql theme={null}
type User @key(fields: "id") @extends {
id: ID! @external
devices: [AuthDevice!]
}
```
## Related Resources
* **[Authentication Guide](../authentication)** - Authentication workflows and examples
* **[Quickstart Guide](../quickstart)** - Getting started with auth
* **[Full SDL Schema](../schemas/sdl/su-auth.graphql)** - Complete type definitions
# Backend Subgraph Reference
Source: https://docs.sensorup.com/api/graphql/subgraphs/backend
Technical reference for the su-backend subgraph providing core platform services.
# Backend Subgraph Reference
The `su-backend` subgraph provides core backend platform services.
## Subgraph Information
* **Name**: `su-backend`
* **Routing URL**: `https://y5mg53yiuk.execute-api.us-west-2.amazonaws.com/poc/graphql`
* **Last Updated**: 2023-10-13
* **SDL**: [View Schema](../schemas/sdl/su-backend.graphql)
## Overview
Core platform functionality and base services.
## Root Query Fields
```graphql theme={null}
extend type Query {
platform: Platform!
}
```
### Platform Query
The `platform` query provides access to platform version information and client configuration.
## Related Resources
* **[Overview](../overview)** - GraphQL API introduction
* **[Full SDL Schema](../schemas/sdl/su-backend.graphql)** - Complete type definitions
# CAM Assets Subgraph Reference
Source: https://docs.sensorup.com/api/graphql/subgraphs/cam-assets
Technical reference for the su-cam-assets subgraph providing Connected Asset Management operations including asset types, properties, and hierarchy.
# CAM Assets Subgraph Reference
The `su-cam-assets` subgraph provides Connected Asset Management (CAM) capabilities for managing asset types, asset properties, and asset hierarchy in connected operations.
## Subgraph Information
* **Name**: `su-cam-assets`
* **Routing URL**: `https://mijlot8lad.execute-api.us-west-2.amazonaws.com/poc/graphql`
* **Last Updated**: 2025-11-03
* **SDL**: [View Schema](../schemas/sdl/su-cam-assets.graphql)
## Overview
CAM Assets manages the foundational structure for connected operations:
* **Asset Types**: Define schemas for different kinds of operational assets
* **Asset Properties**: Custom attributes and their data types
* **Asset Hierarchy**: Parent-child relationships between assets
* **Camera Assets**: Specialized operations for camera and detection assets
* **Batch Operations**: Large-scale asset creation and updates
* **Geospatial**: Full GeoJSON support for asset locations
## Key Concepts
### Asset Types
Asset types define the structure and schema for operational assets:
* **Properties**: Custom attributes (name, data type, required, default value)
* **Extensions**: External data source integrations
* **Status Tracking**: Configuration for asset state management
* **Hierarchy Rules**: Parent-child relationship constraints
### Assets
Assets are instances of asset types representing operational entities:
* **Sites**: Top-level geographic locations
* **Equipment**: Major operational assets
* **Components**: Sub-components within equipment
* **Wells**: Oil and gas well assets
* **Pipelines**: Pipeline infrastructure
### Asset Hierarchy
Assets can be organized in parent-child relationships:
* Multi-level organizational structures
* Inherited properties and configurations
* Hierarchical queries and filtering
* Geographic nesting (e.g., equipment within sites)
## Core Types
### CamAssets
Main entry point for querying assets:
```graphql theme={null}
type CamAssets {
byId(id: ID!): CamAsset
all(
first: Int
after: String
filter: CamAssetFilter
fullTextSearch: CamAssetFullTextSearch
sortBy: CamAssetSortBy
withExtensions: [ID]
includeDelta: Boolean
): CamAssetsConnection
}
```
### CamAsset
Individual asset instance:
```graphql theme={null}
type CamAsset {
id: ID!
name: String!
description: String
assetTypeId: ID!
active: Boolean!
geometry: GeoJSONGeometry
properties: JSONObject
parent: CamAssetReference
children: [CamAssetReference]
status: CamAssetStatus
extensionData: [CamAssetExtensionData]
audit: AuditInfo
}
```
### AssetTypes
Manage asset type definitions:
```graphql theme={null}
type AssetTypes {
byId(assetTypeId: ID!): AssetType
all(
first: Int
after: String
filter: AssetTypeFilter
sortBy: AssetTypeSortBy
): AssetTypesConnection
}
```
### AssetType
Asset type definition:
```graphql theme={null}
type AssetType {
assetTypeId: ID!
name: String!
description: String
properties: [AssetTypeProperty!]
extensions: [AssetTypeExtension!]
parentAssetTypes: [ID!]
childAssetTypes: [ID!]
audit: AuditInfo
}
```
### AssetTypeProperty
Property definition within an asset type:
```graphql theme={null}
type AssetTypeProperty {
id: ID!
name: String!
dataType: PropertyDataType!
required: Boolean!
defaultValue: String
validation: PropertyValidation
displayOrder: Int
}
```
## Query Operations
### camAssets
Query assets by type:
```graphql theme={null}
query GetAssetsByType($assetTypeId: ID!) {
camAssets(assetTypeId: $assetTypeId) {
all(first: 20) {
edges {
node {
id
name
assetTypeId
properties
geometry {
type
coordinates
}
}
}
pageInfo {
hasNextPage
endCursor
}
}
}
}
```
### assetTypes
Query available asset types:
```graphql theme={null}
query GetAssetTypes {
assetTypes {
all(first: 100) {
edges {
node {
assetTypeId
name
description
properties {
id
name
dataType
required
}
}
}
}
}
}
```
### camAssetReferences
Lightweight asset references for dropdowns:
```graphql theme={null}
query GetAssetReferences {
camAssetReferences {
all(first: 100) {
edges {
node {
id
name
assetTypeId
}
}
}
}
}
```
### camEngine
Query CAM engine configuration and datasets:
```graphql theme={null}
query GetCamEngine {
camEngine {
datasets {
id
name
assetTypeId
sourceType
lastUpdated
}
configuration {
key
value
}
}
}
```
### camAssetsDatasets
Get datasets for a specific tenant:
```graphql theme={null}
query GetDatasets($group: ID!) {
camAssetsDatasets(group: $group) {
dataset
displayName
assetTypeId
recordCount
}
}
```
### assetConfigs
Query tenant-specific configurations:
```graphql theme={null}
query GetConfigs($group: ID!) {
assetConfigs(group: $group) {
all {
id
value
updatedAt
}
}
}
```
### generateBatchUpsertUploadUrl
Generate presigned S3 URL for batch operations:
```graphql theme={null}
query GenerateUploadUrl($input: GenerateBatchUpsertUploadUrlInput!) {
generateBatchUpsertUploadUrl(input: $input) {
uploadUrl
batchUpsertReference
expiresAt
}
}
```
### camCatalog
Query catalog configuration for a group:
```graphql theme={null}
query GetCatalog($group: ID!) {
camCatalog(group: $group) {
catalogId
assetTypes {
assetTypeId
name
}
}
}
```
### assetAuditing
Access audit trail information:
```graphql theme={null}
query GetAssetAudit {
assetAuditing {
history(assetId: "asset-123") {
version
eventType
eventTime
updatedBy
}
}
}
```
## Mutation Operations
### createAsset
Create a new asset:
```graphql theme={null}
mutation CreateAsset($input: CreateAssetInput!, $correlationId: ID) {
createAsset(input: $input, correlationId: $correlationId) {
asset {
id
name
assetTypeId
}
correlationId
errors {
message
type
}
}
}
```
### updateAsset
Update an existing asset:
```graphql theme={null}
mutation UpdateAsset($input: UpdateAssetInput!, $correlationId: ID) {
updateAsset(input: $input, correlationId: $correlationId) {
asset {
id
name
properties
}
correlationId
errors {
message
type
}
}
}
```
### updateAssetProperty
Update specific asset properties:
```graphql theme={null}
mutation UpdateAssetProperty($input: UpdateAssetPropertyInput!, $correlationId: ID) {
updateAssetProperty(input: $input, correlationId: $correlationId) {
asset {
id
properties
}
correlationId
errors {
message
type
}
}
}
```
### updateAssetGeometry
Update asset geolocation:
```graphql theme={null}
mutation UpdateAssetGeometry($input: UpdateAssetGeometryInput!, $correlationId: ID) {
updateAssetGeometry(input: $input, correlationId: $correlationId) {
asset {
id
geometry {
type
coordinates
}
}
correlationId
errors {
message
type
}
}
}
```
### createAssetStatus
Create asset status record:
```graphql theme={null}
mutation CreateAssetStatus($input: CreateAssetStatusInput!, $correlationId: ID) {
createAssetStatus(input: $input, correlationId: $correlationId) {
assetStatus {
assetId
statusId
label
setAt
setBy
}
correlationId
errors {
message
type
}
}
}
```
### manageCamAssets
Batch operations for assets:
```graphql theme={null}
mutation ManageAssets {
manageCamAssets(dryRun: false) {
batchUpsert(batchUpsertReference: "ref-from-upload") {
success
processedCount
errors {
row
message
}
}
}
}
```
### setAssetConfig
Update tenant configuration:
```graphql theme={null}
mutation SetConfig($group: ID!, $id: ID!, $value: JSONObject!) {
setAssetConfig(group: $group, id: $id, value: $value) {
config {
id
value
}
correlationId
errors {
message
type
}
}
}
```
### reloadCamAssetsDatasets
Reload datasets from external sources:
```graphql theme={null}
mutation ReloadDatasets($group: ID!) {
reloadCamAssetsDatasets(group: $group) {
dataset
displayName
recordCount
}
}
```
### updateAssetStatus
Update asset status:
```graphql theme={null}
mutation UpdateAssetStatus($input: UpdateAssetStatusInput!, $correlationId: ID) {
updateAssetStatus(input: $input, correlationId: $correlationId) {
asset {
id
status {
statusId
label
}
}
}
}
```
### deleteAssetStatus
Delete asset status record:
```graphql theme={null}
mutation DeleteAssetStatus($input: DeleteAssetStatusInput!, $correlationId: ID) {
deleteAssetStatus(input: $input, correlationId: $correlationId) {
asset {
id
}
}
}
```
### deleteAsset
Delete an asset:
```graphql theme={null}
mutation DeleteAsset($input: DeleteAssetInput!, $correlationId: ID) {
deleteAsset(input: $input, correlationId: $correlationId) {
correlationId
}
}
```
### createAssetType
Create a new asset type:
```graphql theme={null}
mutation CreateAssetType($input: CreateAssetTypeInput!) {
createAssetType(input: $input) {
assetType {
assetTypeId
name
}
}
}
```
### updateAssetType
Update an asset type:
```graphql theme={null}
mutation UpdateAssetType($input: UpdateAssetTypeInput!) {
updateAssetType(input: $input) {
assetType {
assetTypeId
name
}
}
}
```
### activateAssetType
Activate an asset type:
```graphql theme={null}
mutation ActivateAssetType($input: ActivateAssetTypeInput!) {
activateAssetType(input: $input) {
assetType {
assetTypeId
active
}
}
}
```
### deleteAssetType
Delete an asset type:
```graphql theme={null}
mutation DeleteAssetType($input: DeleteAssetTypeInput!) {
deleteAssetType(input: $input) {
correlationId
}
}
```
### flushCamStreamDatasetDelta
Flush streaming dataset delta:
```graphql theme={null}
mutation FlushDatasetDelta($streamDatasetId: ID!) {
flushCamStreamDatasetDelta(streamDatasetId: $streamDatasetId)
}
```
### deleteAssetConfig
Delete asset configuration:
```graphql theme={null}
mutation DeleteAssetConfig($group: ID!, $id: ID!) {
deleteAssetConfig(group: $group, id: $id) {
correlationId
}
}
```
## Deprecated Operations
The following legacy operations are deprecated in favor of the unified `camAssets` query:
* `assetSites` → Use `camAssets(assetTypeId: "site")`
* `assetEquipments` → Use `camAssets(assetTypeId: "equipment")`
* `assetComponents` → Use `camAssets(assetTypeId: "component")`
* `assetWells` → Use `camAssets(assetTypeId: "well")`
* `assetPipelines` → Use `camAssets(assetTypeId: "pipeline")`
* `assetUnattributeds` → Use `camAssets` without assetTypeId filter
## Filtering and Sorting
### CamAssetFilter
Filter assets by various criteria:
```graphql theme={null}
input CamAssetFilter {
active: Boolean
assetTypeIds: [ID!]
parentId: ID
geometry: GeoJSONGeometryFilter
properties: JSONObject
extensionIds: [ID!]
}
```
### CamAssetFullTextSearch
Search assets by text:
```graphql theme={null}
input CamAssetFullTextSearch {
text: String!
fields: [String!] # Search specific fields
}
```
### CamAssetSortBy
Sort asset results:
```graphql theme={null}
input CamAssetSortBy {
field: CamAssetSortField!
direction: SortDirection!
}
enum CamAssetSortField {
NAME
CREATED_AT
UPDATED_AT
ASSET_TYPE_ID
}
```
## GeoJSON Support
Full GeoJSON geometry types supported:
```graphql theme={null}
union GeoJSONGeometry =
| GeoJSONPoint
| GeoJSONLineString
| GeoJSONPolygon
| GeoJSONMultiPoint
| GeoJSONMultiLineString
| GeoJSONMultiPolygon
| GeoJSONGeometryCollection
```
### Example Geometries
**Point:**
```json theme={null}
{
"type": "Point",
"coordinates": [-114.0719, 51.0447]
}
```
**Polygon:**
```json theme={null}
{
"type": "Polygon",
"coordinates": [[
[-114.073, 51.045],
[-114.071, 51.045],
[-114.071, 51.044],
[-114.073, 51.044],
[-114.073, 51.045]
]]
}
```
## Audit Information
All assets include audit metadata:
```graphql theme={null}
type AuditInfo {
createdAt: DateTime!
createdBy: UserReference
updatedAt: DateTime
updatedBy: UserReference
version: Int
}
```
## Error Handling
Mutations return standardized error types:
```graphql theme={null}
type AssetMutationResult {
asset: CamAsset
correlationId: ID
errors: [AssetMutationError!]
}
type AssetMutationError implements MutationError {
message: String!
type: String!
}
```
Common error types:
* `DUPLICATE_ID`: Asset ID already exists
* `INVALID_PARENT`: Parent asset not found or invalid type
* `INVALID_PROPERTY`: Property validation failed
* `INVALID_GEOMETRY`: GeoJSON geometry is malformed
* `MISSING_REQUIRED`: Required field not provided
* `INVALID_ASSET_TYPE`: Asset type does not exist
## Extension System
Assets can integrate with external data sources through extensions:
```graphql theme={null}
type AssetTypeExtension {
id: ID!
name: String!
sourceType: ExtensionSourceType!
connectionDetails: AssetTypeExtensionConnectionDetails
stateSyncProperties: [AssetTypeExtensionStateSyncProperty!]
statusProperties: [AssetTypeExtensionStatusProperty!]
}
enum ExtensionSourceType {
DATABASE
API
FILE
STREAM
}
```
## Batch Operations
### Upload Flow
1. Generate presigned S3 upload URL
2. Upload CSV/JSONL file to S3
3. Trigger batch upsert with reference
4. Monitor processing status
### File Formats
**CSV:**
```csv theme={null}
id,name,assetTypeId,properties.operator,geometry.coordinates
site-001,Station A,site,ACME Energy,"[-114.0719,51.0447]"
```
**JSONL:**
```jsonl theme={null}
{"id":"site-001","name":"Station A","assetTypeId":"site","properties":{"operator":"ACME Energy"},"geometry":{"type":"Point","coordinates":[-114.0719,51.0447]}}
```
## Related Resources
* **[CAM Assets Guide](../guides/cam-assets)** - Comprehensive usage guide
* **[Common Patterns](../common-patterns)** - Pagination and filtering
* **[Full SDL Schema](../schemas/sdl/su-cam-assets.graphql)** - Complete type definitions
* **[Core Platform Guide](../guides/core-platform)** - Maps and geospatial services
# Catalog Subgraph Reference
Source: https://docs.sensorup.com/api/graphql/subgraphs/catalog
Technical reference for the su-catalog subgraph providing data catalog and metadata services.
# Catalog Subgraph Reference
The `su-catalog` subgraph provides data catalog and metadata management.
## Subgraph Information
* **Name**: `su-catalog`
* **Routing URL**: `https://mhwrba73jc.execute-api.us-west-2.amazonaws.com/poc/graphql`
* **Last Updated**: 2023-10-13
* **SDL**: [View Schema](../schemas/sdl/su-catalog.graphql)
## Overview
Dataset catalog, observed properties, and metadata management.
## Root Query Fields
```graphql theme={null}
extend type Query {
catalogs(withInternal: Boolean): Catalogs
catalogDatasets(withInternal: Boolean): UpSpecifications
pipeCatalogs: Catalogs @deprecated
}
```
## Root Mutation Fields
```graphql theme={null}
extend type Mutation {
provisionCatalogDataset(
input: ProvisionCatalogDatasetInput!
mutationId: ID!
correlationId: ID
): UpSpecificationMutationResult
}
```
## Related Resources
* **[Full SDL Schema](../schemas/sdl/su-catalog.graphql)** - Complete type definitions
# Detections Ingress Subgraph Reference
Source: https://docs.sensorup.com/api/graphql/subgraphs/detections-ingress
Technical reference for the su-detections-ingress subgraph handling detection data ingestion.
# Detections Ingress Subgraph Reference
The `su-detections-ingress` subgraph handles incoming detection data ingestion.
## Subgraph Information
* **Name**: `su-detections-ingress`
* **Routing URL**: `https://rur9cuj7p0.execute-api.us-west-2.amazonaws.com/poc/graphql`
* **Last Updated**: 2025-10-09
* **SDL**: [View Schema](../schemas/sdl/su-detections-ingress.graphql)
## Overview
Detection dataset ingestion and registration.
## Root Query Fields
```graphql theme={null}
extend type Query {
detectionsIngressDatasets(group: ID): [CamEngineDataset!]!
}
```
## Root Mutation Fields
```graphql theme={null}
extend type Mutation {
reloadDetectionsIngressDatasets(group: ID): [CamEngineDataset!]!
}
```
## Related Resources
* **[Emissions Guide](../guides/emissions)** - Detection workflows
* **[Full SDL Schema](../schemas/sdl/su-detections-ingress.graphql)** - Complete type definitions
# Event Hub Subgraph Reference
Source: https://docs.sensorup.com/api/graphql/subgraphs/eventhub
Technical reference for the su-eventhub subgraph providing event publishing and subscriptions.
# Event Hub Subgraph Reference
The `su-eventhub` subgraph provides event publishing and subscription capabilities.
## Subgraph Information
* **Name**: `su-eventhub`
* **Routing URL**: `https://c5913dk85i.execute-api.us-west-2.amazonaws.com/poc/graphql`
* **Last Updated**: 2025-08-01
* **SDL**: [View Schema](../schemas/sdl/su-eventhub.graphql)
## Overview
Event-driven integration and notifications.
## Root Query Fields
```graphql theme={null}
extend type Query {
eventHubPublishedEvents: EventHubPublishedEvents
}
```
## Related Resources
* **[Overview](../overview)** - GraphQL API introduction
* **[Full SDL Schema](../schemas/sdl/su-eventhub.graphql)** - Complete type definitions
# Forms Subgraph Reference
Source: https://docs.sensorup.com/api/graphql/subgraphs/forms
Technical reference for the su-forms subgraph providing dynamic XForms data collection.
# Forms Subgraph Reference
The `su-forms` subgraph provides dynamic form definitions and data collection using ODK XForms.
## Subgraph Information
* **Name**: `su-forms`
* **Routing URL**: `https://9gfflct3kf.execute-api.us-west-2.amazonaws.com/poc/graphql`
* **Last Updated**: 2023-10-13
* **SDL**: [View Schema](../schemas/sdl/su-forms.graphql)
## Overview
XForms-based data collection, form templates, and responses.
## Root Query Fields
```graphql theme={null}
extend type Query {
formLists: FormLists
}
```
## Root Mutation Fields
```graphql theme={null}
extend type Mutation {
createFormList(input: CreateFormListInput!, mutationId: ID, correlationId: ID): FormListMutationResult
updateFormList(input: UpdateFormListInput!, mutationId: ID, correlationId: ID): FormListMutationResult
}
```
## Related Resources
* **[Full SDL Schema](../schemas/sdl/su-forms.graphql)** - Complete type definitions
# Issues Subgraph Reference
Source: https://docs.sensorup.com/api/graphql/subgraphs/issues
Technical reference for the su-issues subgraph providing issue tracking and task management.
# Issues Subgraph Reference
The `su-issues` subgraph provides comprehensive issue tracking, task management, and data collection capabilities.
## Subgraph Information
* **Name**: `su-issues`
* **Routing URL**: `https://6vapx1z4c0.execute-api.us-west-2.amazonaws.com/poc/graphql`
* **Last Updated**: 2025-11-03
* **SDL**: [View Schema](../schemas/sdl/su-issues.graphql)
## Overview
This subgraph owns:
* Issue creation and management
* Task and multi-task coordination
* Issue templates
* Data collection forms (XForms integration)
* Annotations and comments
* Issue-asset relationships
## Root Query Fields
```graphql theme={null}
extend type Query {
# Issue Management
issues: Issues
allIssues(after: String, first: Int, status: IssueStatus, severity: Int, subjectReference: ID, triggerReference: ID): IssuesConnection
openIssueBySubjectAndReference(subjectReference: ID!, triggerReference: ID!): Issue
# Issue Types
issueMultitask: IssueMultitask
issueTask: IssueTask
issueSeverityTypes: [IssueSeverityDisplay!]
# Forms & Datasets
issueDataCollectionFormReferences: [IssueDataCollectionForm!] @deprecated
formDatasets(group: ID!): [CamEngineDataset!]!
issuesDatasets(group: ID!): [CamEngineDataset]!
}
```
## Root Mutation Fields
```graphql theme={null}
extend type Mutation {
# Issue Lifecycle
triggerIssue(input: TriggerIssueInput!, delayed: DelayedIssueMutationInput): IssueMutationResult!
updateIssue(input: UpdateIssueInput!, delayed: DelayedIssueMutationInput): IssueMutationResult!
deleteIssue(input: DeleteIssueInput!, delayed: DelayedIssueMutationInput): IssueMutationResult!
undeleteIssue(input: UndeleteIssueInput!, delayed: DelayedIssueMutationInput): IssueMutationResult!
transitionIssueState(input: TransitionIssueStateInput!, delayed: DelayedIssueMutationInput): IssueMutationResult!
closeIssue(input: CloseIssueInput!, delayed: DelayedIssueMutationInput): IssueMutationResult! @deprecated
reopenIssue(input: ReopenIssueInput!, delayed: DelayedIssueMutationInput): IssueMutationResult! @deprecated
# Multitask & Subtasks
triggerIssueMultitask(input: TriggerIssueMultitaskInput!, delayed: DelayedIssueMutationInput): IssueMutationResult!
triggerIssueSubTask(input: TriggerIssueSubTaskInput!, delayed: DelayedIssueMutationInput): IssueMutationResult!
createMultitaskProcedure(input: CreateMultitaskProcedureInput!): IssueMultitaskProcedureMutationResult!
triggerIssueTask(input: TriggerIssueTaskInput!, delayed: DelayedIssueMutationInput): IssueMutationResult!
# Assignment & Comments
assignIssueToUser(input: AssignIssueToUserInput!, delayed: DelayedIssueMutationInput): IssueMutationResult!
acknowledgeAssignment(input: AcknowledgeAssignment!, delayed: DelayedIssueMutationInput): IssueMutationResult!
commentIssue(input: CommentIssueInput!, delayed: DelayedIssueMutationInput): IssueMutationResult!
deleteIssueComment(input: DeleteIssueCommentInput!, delayed: DelayedIssueMutationInput): IssueMutationResult!
modifyIssueComment(input: ModifyIssueCommentInput!, delayed: DelayedIssueMutationInput): IssueMutationResult!
# State & Data
updateIssueStateData(input: UpdateIssueStateDataInput, delayed: DelayedIssueMutationInput): IssueMutationResult!
bulkUpdateIssues(input: BulkUpdateIssuesInput!, delayed: DelayedIssueMutationInput): BulkIssuesMutationResult!
# Data Collection Forms
createIssueTaskDataCollectionForm(input: CreateIssueTaskDataCollectionFormInput!): IssueTaskDataCollectionFormMutationResult!
updateIssueTaskDataCollectionForm(input: UpdateIssueTaskDataCollectionFormInput!): IssueTaskDataCollectionFormMutationResult!
deleteIssueTaskDataCollectionForm(input: DeleteIssueTaskDataCollectionFormInput!): IssueTaskDataCollectionFormMutationResult!
activateIssueTaskDataCollectionForm(id: ID!, subjectAssetProfile: ID): IssueTaskDataCollectionFormMutationResult!
deactivateIssueTaskDataCollectionForm(id: ID!): IssueTaskDataCollectionFormMutationResult!
cloneIssueTaskDataCollectionForm(input: CloneIssueTaskDataCollectionFormInput!): IssueTaskDataCollectionFormMutationResult!
# Datasets
reloadFormDatasets(group: ID): [CamEngineDataset!]!
generateFormResponseDataset(async: Boolean! = true, formReference: String!): FormResponseCamDatasetGenerateResults!
generateFormResponseDatasets(async: Boolean! = true): FormResponseCamDatasetGenerateResults!
}
```
## Core Types
### Issue
Main issue/task type.
```graphql theme={null}
type Issue implements Node @key(fields: "id") {
id: ID!
type: IssueType! # ISSUE, TASK, MULTITASK, SUBTASK
taskType: IssueTaskType
title: String!
description: String
status: IssueStatus! # OPEN, IN_PROGRESS, RESOLVED, CLOSED
severity: Int!
openedAt: DateTime!
closedAt: DateTime
dueAt: DateTime
pastDue: Boolean
subject: IssueSubject!
trigger: IssueTrigger!
annotations: [Annotation]
assignee: IssueAssignee
watchers: [IssueWatcher!]
currentState: IssueState!
auditHistory: [IssueAuditEntry!]!
parentIssue: IssueReference
}
```
### IssueTemplate
Reusable issue definition.
```graphql theme={null}
type IssueTemplate @key(fields: "id") {
id: ID!
title: String!
description: String
type: IssueType!
defaultSeverity: Int
defaultDueInDays: Int
formReference: XFormReference
}
```
## XForms Integration
Issues can include data collection forms:
```graphql theme={null}
type XFormDetails {
model: XFormXMLNode!
binds: [XFormBind!]
body: [XFormBodyNode!]
}
type XFormBind {
nodeset: String!
type: XFormDataType! # string, int, decimal, date, geopoint, etc.
required: XFormXPath
constraint: XFormXPath
}
```
## Entity Extensions
### Asset
Extends Asset with issue subject information.
```graphql theme={null}
type Asset @key(fields: "profile id") @extends {
profile: ID! @external
id: ID! @external
issueSubject: IssueSubject!
}
```
## Related Resources
* **[Full SDL Schema](../schemas/sdl/su-issues.graphql)** - Complete type definitions
# Maps Subgraph Reference
Source: https://docs.sensorup.com/api/graphql/subgraphs/maps
Technical reference for the su-maps subgraph providing mapping and visualization services.
# Maps Subgraph Reference
The `su-maps` subgraph provides mapping, visualization, and geospatial services.
## Subgraph Information
* **Name**: `su-maps`
* **Routing URL**: `https://jeoej0m171.execute-api.us-west-2.amazonaws.com/poc/graphql`
* **Last Updated**: 2025-02-07
* **SDL**: [View Schema](../schemas/sdl/su-maps.graphql)
## Overview
Map configurations, layers, and geospatial visualization.
## Root Query Fields
```graphql theme={null}
extend type Query {
maps: Maps
mapsConfig: MapsConfig
}
```
## Root Mutation Fields
```graphql theme={null}
extend type Mutation {
createMap(input: CreateMapInput!): MapMutationResult!
cloneMap(id: ID!): MapMutationResult!
updateMap(input: UpdateMapInput!): MapMutationResult!
recordMapViewed(id: ID!): MapMutationResult!
deleteMap(id: ID!): MapMutationResult!
}
```
## Related Resources
* **[Full SDL Schema](../schemas/sdl/su-maps.graphql)** - Complete type definitions
# Methane LDAR Backend Subgraph Reference
Source: https://docs.sensorup.com/api/graphql/subgraphs/methane-ldar-backend
Technical reference for the su-methane-ldar-backend subgraph providing LDAR operations and emission tracking.
# Methane LDAR Backend Subgraph Reference
The `su-methane-ldar-backend` subgraph provides comprehensive Leak Detection and Repair (LDAR) operations, emission observation tracking, and inspection workflow management.
## Subgraph Information
* **Name**: `su-methane-ldar-backend`
* **Routing URL**: `https://x2ex1v41i5.execute-api.us-west-2.amazonaws.com/poc/graphql`
* **Last Updated**: 2025-09-25
* **SDL**: [View Schema](../schemas/sdl/su-methane-ldar-backend.graphql)
## Overview
This subgraph owns:
* Emission observations (detections)
* Inspection requests (OGI, drone)
* Equipment and component clues
* Detection resolution workflows
* Emission observation reports
* Compliance severity tracking
## Root Query Fields
```graphql theme={null}
extend type Query {
emissionObservations: EmissionObservations
emissionObservationReports: EmissionObservationReports
inspectionRequests: InspectionRequests
noDetections: NoDetections
emissionEvents: EmissionEvents
methaneLdarBackendDatasets(group: ID!): [CamEngineDataset!]!
methaneLdarBackendConfig: EmissionConfig
methaneLdarBackendConfigs(group: ID!): EmissionConfigs
genAi: GenAi
}
```
## Root Mutation Fields
```graphql theme={null}
extend type Mutation {
# Emission Observation Operations
createEmissionObservation(input: CreateEmissionObservationInput!): EmissionObservationMutationResult!
deleteEmissionObservation(input: DeleteEmissionObservationInput!): EmissionObservationMutationResult!
acknowledgeEmissionObservation(input: AcknowledgeEmissionObservationInput!): EmissionObservationMutationResult!
attributeEmissionObservationToEquipment(input: AttributeEmissionObservationToEquipmentInput!): AttributeEmissionObservationToEquipmentResult!
attributeEmissionObservationToSite(input: AttributeEmissionObservationToSiteInput!): AttributeEmissionObservationToSiteResult!
attributeEmissionObservationsToEquipment(input: AttributeEmissionObservationsToEquipmentInput!): AttributeEmissionObservationsToEquipmentResult!
# Detection Operations
createDetection(input: CreateDetectionInput!): DetectionMutationResult!
updateDetection(input: UpdateDetectionInput!): DetectionMutationResult!
updateHistoricalDetection(input: UpdateHistoricalDetectionInput!): DetectionMutationResult!
resolveDetection(input: ResolveDetectionInput!): DetectionMutationResult!
pendDetection(input: PendDetectionInput!): DetectionMutationResult!
# Venting Event Operations
createVentingEvent(input: CreateVentingEventInput!): VentingEventMutationResult!
updateVentingEvent(input: UpdateVentingEventInput!): UpdateVentingEventResult!
# Inspection Request Operations
createInspectionRequest(input: CreateInspectionRequestInput!): InspectionRequestMutationResult!
updateInspectionRequest(input: UpdateInspectionRequestInput!): InspectionRequestMutationResult!
updateInspectionRequestStatus(input: UpdateInspectionRequestStatusInput!): InspectionRequestMutationResult!
# Clue Operations
updateClue(input: UpdateClueInput!): ClueMutationResult!
# No Detection Operations
createNoDetection(input: CreateNoDetectionInput!): NoDetectionMutationResult!
updateNoDetection(input: UpdateNoDetectionInput!): NoDetectionMutationResult!
deleteNoDetection(input: DeleteNoDetectionInput!): NoDetectionMutationResult!
# Emission Event Operations
createEmissionEvent(input: CreateEmissionEventInput!): EmissionEventMutationResult!
updateEmissionEventFalseAlarmStatus(input: UpdateEmissionEventFalseAlarmStatusInput!): EmissionEventMutationResult! @deprecated
updateEmissionEventStatus(input: UpdateEmissionEventStatusInput!): EmissionEventMutationResult!
attributeEmissionEvent(input: EmissionEventAttributionInput!): EmissionEventMutationResult!
correlateEmissionEvents(input: EmissionEventsCorrelationInput!): EmissionEventsCorrelationResult!
unCorrelateEmissionEvents(input: EmissionEventsUncorrelationInput!): EmissionEventsUncorrelationResult!
deleteEmissionEvents(input: DeleteEmissionEventsInput!): EmissionEventMutationResult!
# Alarm Operations
createAlarm(input: CreateEmissionAlarmInput!): EmissionAlarmMutationResult!
updateAlarm(input: UpdateEmissionAlarmInput!): EmissionAlarmMutationResult!
# Dataset & Configuration Operations
reloadMethaneLdarBackendDatasets(group: ID!): [CamEngineDataset!]!
generateNoDetectionsDatasets(input: NoDetectionsDatasetsInput!): NoDetectionsDatasetsResult!
setMethaneLdarConfig(group: ID!, id: ID!, value: JSONObject!): EmissionConfigMutationResult
manageEmissions(dryRun: Boolean): ManageEmissionsMutation
}
```
## Core Types
### EmissionObservation
Detected emission event requiring investigation.
```graphql theme={null}
type EmissionObservation @key(fields: "id") {
id: ID!
displayName: String!
priority: EmissionObservationPriority! # HIGH(100), MEDIUM(50), LOW(1)
status: DetectionStatus!
detectionType: DetectionType! # SATELLITE, FLYOVER, DRONE, OGI, etc.
phenomenonTime: DateTime!
receivedAt: DateTime!
geometry: GeoJSONGeometryInterface
clues: [ClueReference!]
inspectionRequests: [InspectionRequestReference!]
resolutionMode: ResolutionMode
audit: EmissionObservationAudit!
}
```
### Detection Types
```graphql theme={null}
enum DetectionType {
DETECTION_TYPE_SATELLITE
DETECTION_TYPE_FLYOVER
DETECTION_TYPE_DRONE
DETECTION_TYPE_OGI # Optical Gas Imaging
DETECTION_TYPE_CMS # Continuous Monitoring System
DETECTION_TYPE_OWD # On-site Walk Down
DETECTION_TYPE_VENTING_FLARING_BLOWDOWN
DETECTION_TYPE_MANUAL
}
```
### Detection Status
```graphql theme={null}
enum DetectionStatus {
DETECTION_STATUS_NEW
DETECTION_STATUS_VISUAL_INSPECTION_SCHEDULED
DETECTION_STATUS_VISUAL_INSPECTION_COMPLETED
DETECTION_STATUS_OGI_REQUESTED
DETECTION_STATUS_OGI_SCHEDULED
DETECTION_STATUS_OGI_COMPLETED
DETECTION_STATUS_LEAK_REPAIR_SCHEDULED
DETECTION_STATUS_LEAK_REPAIRED
DETECTION_STATUS_VERIFICATION_SCHEDULED
DETECTION_STATUS_RESOLVED
}
```
### InspectionRequest
Request for follow-up inspection.
```graphql theme={null}
type InspectionRequest {
id: ID!
detectionReference: DetectionReference!
inspectionType: InspectionType! # INSPECTION_OGI, INSPECTION_DRONE
status: InspectionStatus!
additionalComment: String
clues: [ClueReference!]
requestedBy: InspectionRequestRequester
audit: InspectionRequestAudit!
siteId: ID
multitaskProcedureId: String
}
```
### Equipment & Clues
Equipment context for detections:
```graphql theme={null}
type Equipment {
id: ID!
name: String!
description: String
siteReference: SiteReference!
components: [EquipmentComponent!]
}
type Clue {
clueId: ID!
displayName: String!
equipment: Equipment
}
```
## Resolution Modes
```graphql theme={null}
enum ResolutionMode {
DETECTION_RESOLVED_CORRELATED # Correlated with another detection
DETECTION_RESOLVED_FALSE_ALARM # False positive
DETECTION_RESOLVED_READY_TO_RECONCILE # Ready for compliance reporting
}
```
## Entity Extensions
### Site
Extends Site with emission observation reports.
```graphql theme={null}
type SiteReference @key(fields: "siteId") {
siteId: ID!
emissionObservationReports: EmissionObservationMonthSiteReportConnection
}
```
## Related Resources
* **[Emissions Guide](../guides/emissions)** - LDAR workflows and examples
* **[Full SDL Schema](../schemas/sdl/su-methane-ldar-backend.graphql)** - Complete type definitions
# Methane Reconcile Backend Subgraph Reference
Source: https://docs.sensorup.com/api/graphql/subgraphs/methane-reconcile-backend
Technical reference for the su-methane-reconcile-backend subgraph providing emissions reconciliation.
# Methane Reconcile Backend Subgraph Reference
The `su-methane-reconcile-backend` subgraph provides emissions reconciliation and compliance reporting.
## Subgraph Information
* **Name**: `su-methane-reconcile-backend`
* **Routing URL**: `https://8fzyria1t5.execute-api.us-west-2.amazonaws.com/poc/graphql`
* **Last Updated**: 2025-08-15
* **SDL**: [View Schema](../schemas/sdl/su-methane-reconcile-backend.graphql)
## Overview
Emissions reconciliation, compliance status, and reporting.
## Root Query Fields
```graphql theme={null}
extend type Query {
reconciledEmissions: ReconciledEmissions
reconciledReports: ReconciledReports
reconciledDecisions: ReconciledDecisions
reconciliationErrors: ReconciliationErrors
co2eSiteMonthReports: Co2eSiteMonthReports
co2eMonthReports: Co2eMonthReports
scope2Emissions: Scope2Emissions
reconciliationSiteMonths: ReconciliationSiteMonths
reconciliationMonths: ReconciliationMonths
reconciliationReports: ReconciliationReports
}
```
## Root Mutation Fields
```graphql theme={null}
extend type Mutation {
updateReconciledEmission(input: UpdateReconciledEmissionInput!): ReconciledEmissionMutationResult!
logReconciliationError(input: LogReconciliationErrorInput!): ReconciliationErrorMutationResult!
logReconciliationDecision(input: LogReconciliationDecisionInput!): ReconciliationDecisionMutationResult!
confirmReconciliationDecision(input: ConfirmReconciliationDecisionInput!): ReconciliationDecisionMutationResult!
requestDecisionsReviewForApproval(input: RequestDecisionsReviewForApprovalInput!): ReconciliationDecisionMutationResult!
approveDecisionsReviewRequest(input: ApproveDecisionsReviewRequestInput!): ReconciliationDecisionMutationResult!
reopenReconciliationSiteMonth(input: ReopenReconciliationSiteMonthInput!): ReconciliationSiteMonthMutationResult!
exportReconciledEmissions(input: ExportReconciledEmissionsInput!): ExportReconciledEmissionsMutationResult!
updateScope2Emission(input: UpdateScope2EmissionInput!): Scope2EmissionMutationResult!
triggerReconciliation(input: TriggerReconciliationInput!): TriggerReconciliationMutationResult!
reconcileEmissionEvents(input: ReconcileEmissionEventsInput!): ReconcileEmissionEventsMutationResult!
upsertRolledUpReconciledEmissions(input: UpsertRolledUpReconciledEmissionsInput!): RolledUpReconciledEmissionsMutationResult!
}
```
## Related Resources
* **[Emissions Guide](../guides/emissions)** - Reconciliation workflows
* **[Full SDL Schema](../schemas/sdl/su-methane-reconcile-backend.graphql)** - Complete type definitions
# Sites Subgraph Reference
Source: https://docs.sensorup.com/api/graphql/subgraphs/sites
Technical reference for the su-sites subgraph providing site management.
# Sites Subgraph Reference
**Deprecated**: The `su-sites` subgraph is deprecated and will be removed in a future release. For geospatial operations and site management, use the **[Maps API](../subgraphs/maps)** (`su-maps`) instead. For connected asset management including asset hierarchy and locations, use the **[CAM Assets API](../subgraphs/cam-assets)** (`su-cam-assets`).
The `su-sites` subgraph provides site management and hierarchy capabilities.
## Subgraph Information
* **Name**: `su-sites`
* **Routing URL**: `https://2af2daotz8.execute-api.us-west-2.amazonaws.com/poc/graphql`
* **Last Updated**: 2024-07-22
* **SDL**: [View Schema](../schemas/sdl/su-sites.graphql)
## Overview
Physical sites, hierarchies, boundaries, and geospatial operations.
## Related Resources
* **[Maps Subgraph Reference](./maps)** - Modern geospatial API (recommended)
* **[CAM Assets Guide](../guides/cam-assets)** - Asset hierarchy and locations
* **[Core Platform Guide](../guides/core-platform)** - Maps and geospatial services
* **[Full SDL Schema](../schemas/sdl/su-sites.graphql)** - Complete type definitions
# User Subgraph Reference
Source: https://docs.sensorup.com/api/graphql/subgraphs/user
Technical reference for the su-user subgraph providing user management.
# User Subgraph Reference
The `su-user` subgraph provides user profile and management capabilities.
## Subgraph Information
* **Name**: `su-user`
* **Routing URL**: `https://a4g6fd62uk.execute-api.us-west-2.amazonaws.com/poc/graphql`
* **Last Updated**: 2025-06-23
* **SDL**: [View Schema](../schemas/sdl/su-user.graphql)
## Overview
User profiles, permissions, and account management.
## Root Query Fields
```graphql theme={null}
extend type Query {
userGroups: [UserGroup!]
userConsentDocuments: [ConsentDocument!]
me: User
users: [User!]
issueUserAssignees: [User!]
}
```
## Root Mutation Fields
```graphql theme={null}
extend type Mutation {
updateGroup(input: UpdateGroupInput!): UpdateGroupMutationResult!
updateUserMeConsent(input: UpdateUserMeConsentInput!): UpdateUserMeConsentMutationResult!
createUser(input: CreateUserInput!): UserMutationResult!
updateUser(input: UpdateUserInput!): UserMutationResult!
updateUserPreference(input: UpdateUserPreferenceInput!): UserMutationResult!
updateUserRegisterNotificationToken(input: UpdateUserNotificationTokenInput!): UserMutationResult!
updateUserUnregisterNotificationToken(input: UpdateUserNotificationTokenInput!): UserMutationResult!
deleteUser(input: DeleteUserInput!): UserMutationResult!
loginMe: UserMutationResult!
}
```
## Related Resources
* **[Authentication Guide](../authentication)** - User authentication
* **[Full SDL Schema](../schemas/sdl/su-user.graphql)** - Complete type definitions
# Workflow Subgraph Reference
Source: https://docs.sensorup.com/api/graphql/subgraphs/workflow
Technical reference for the su-workflow subgraph providing workflow state machines.
# Workflow Subgraph Reference
The `su-workflow` subgraph provides workflow definitions and state machine management.
## Subgraph Information
* **Name**: `su-workflow`
* **Routing URL**: `https://mx2birfjx1.execute-api.us-west-2.amazonaws.com/poc/graphql`
* **Last Updated**: 2023-10-13
* **SDL**: [View Schema](../schemas/sdl/su-workflow.graphql)
## Overview
Workflow state machines, transitions, and orchestration.
## Root Query Fields
```graphql theme={null}
extend type Query {
workflows(withInternal: Boolean): Workflows
}
```
## Root Mutation Fields
```graphql theme={null}
extend type Mutation {
createWorkflow(input: CreateWorkflowInput!): WorkflowMutationResult!
cloneWorkflow(id: ID!): WorkflowMutationResult!
updateWorkflow(input: UpdateWorkflowInput!): WorkflowMutationResult!
deleteWorkflow(id: ID!): WorkflowMutationResult!
transferWorkflow(id: ID!, group: String!, username: String!): WorkflowMutationResult!
activateWorkflow(id: ID!): WorkflowMutationResult!
deactivateWorkflow(id: ID!): WorkflowMutationResult!
}
```
## Related Resources
* **[Full SDL Schema](../schemas/sdl/su-workflow.graphql)** - Complete type definitions
# MCP Usage Examples
Source: https://docs.sensorup.com/api/mcp/examples
Practical examples of using SensorUp MCP tools with AI assistants
## Overview
This guide provides practical examples of how to use SensorUp MCP tools with AI assistants. These examples demonstrate common use cases and best practices.
## Basic Queries
### Listing Assets
**Prompt:**
```
Using the SensorUp MCP tool, show me all my assets
```
**What Happens:**
The AI assistant will use the Asset Tool to query your assets and present them in a readable format.
**Expected Response:**
* List of asset names and IDs
* Asset status information
* Basic metadata
***
### Getting Emission Events
**Prompt:**
```
Show me emission events from the last 7 days using SensorUp MCP
```
**What Happens:**
The AI assistant will use the Event Tool with appropriate date filters to retrieve recent emission events.
**Expected Response:**
* List of emission events
* Event dates and times
* Event status and details
***
## Advanced Queries
### Analyzing Trends
**Prompt:**
```
Using SensorUp MCP, analyze emission trends for the last 30 days and identify any patterns
```
**What Happens:**
The AI assistant will:
1. Use the Analytics Tool to retrieve emission data
2. Process the data to identify trends
3. Present insights in a clear format
**Expected Response:**
* Trend analysis
* Pattern identification
* Data visualization suggestions
***
### Asset Status Monitoring
**Prompt:**
```
Check the status of all my assets and alert me to any that are inactive
```
**What Happens:**
The AI assistant will:
1. Query all assets using the Asset Tool
2. Filter by status
3. Highlight inactive assets
**Expected Response:**
* Summary of asset statuses
* List of inactive assets
* Suggested actions
***
## Complex Workflows
### Event Investigation
**Prompt:**
```
Using SensorUp MCP, find the emission event with the highest rate from last month and show me its details including associated assets
```
**What Happens:**
The AI assistant will:
1. Query emission events from last month
2. Identify the event with the highest rate
3. Retrieve detailed event information
4. Query associated asset data
5. Present a comprehensive report
**Expected Response:**
* Event details
* Emission rate information
* Associated asset information
* Timeline data
***
### Custom Reporting
**Prompt:**
```
Create a summary report of my emission operations for the last quarter using SensorUp MCP
```
**What Happens:**
The AI assistant will:
1. Query emission events for the quarter
2. Retrieve relevant analytics
3. Aggregate the data
4. Format it as a report
**Expected Response:**
* Summary statistics
* Key metrics
* Trend analysis
* Comparative data
***
## Integration Patterns
### Daily Monitoring
**Use Case:** Set up daily emission monitoring
**Prompt:**
```
Check my SensorUp data for any new emission events today and summarize them
```
**Benefits:**
* Quick daily updates
* Early issue detection
* Consistent monitoring
***
### Asset Health Checks
**Use Case:** Regular asset status reviews
**Prompt:**
```
Review the health status of all my assets and identify any that need attention
```
**Benefits:**
* Proactive maintenance
* Status visibility
* Operational insights
***
## Best Practices
### 1. Be Specific with Time Ranges
Good: "Show me events from the last 7 days"
Better: "Show me emission events from January 1-7, 2025"
### 2. Request Relevant Fields
Good: "Get asset data"
Better: "Get asset names, IDs, and current status"
### 3. Use Follow-up Questions
Start broad, then drill down:
1. "Show me all emission events"
2. "Show me details for event #12345"
3. "What assets are associated with that event?"
### 4. Combine Multiple Queries
Ask for related data in one prompt:
"Show me emission events from last week and the associated asset status for each event"
## Troubleshooting
### No Data Returned
**Issue:** Query returns empty results
**Solutions:**
* Verify date ranges are correct
* Check filter parameters
* Confirm you have data for the requested period
### Permission Errors
**Issue:** Tool reports insufficient permissions
**Solutions:**
* Verify your API key permissions
* Check user role assignments
* Contact your administrator
### Rate Limit Reached
**Issue:** Tool reports rate limit exceeded
**Solutions:**
* Wait before making additional requests
* Reduce query frequency
* Optimize query patterns
## Related Resources
* [Getting Started](/api/mcp/getting-started)
* [Available Tools](/api/mcp/tools)
* [GraphQL Query Patterns](/api/graphql/common-patterns)
* [API Authentication](/api/graphql/authentication)
# Getting Started with MCP
Source: https://docs.sensorup.com/api/mcp/getting-started
Learn how to set up and configure SensorUp MCP tools for your AI assistant
## Prerequisites
Before you begin, ensure you have:
* A SensorUp account with appropriate permissions
* An API key for authentication (see [Authentication](/api/graphql/authentication))
* An MCP-compatible AI assistant or application (e.g., Claude Desktop, Cline, etc.)
## Installation
### Using npx (Recommended)
The SensorUp MCP server can be installed and run using npx:
```bash theme={null}
npx @sensorup/mcp-server
```
### Using npm
Alternatively, install globally:
```bash theme={null}
npm install -g @sensorup/mcp-server
```
## Configuration
### MCP Server Configuration
Configure your MCP client to connect to the SensorUp MCP server. The configuration will vary depending on your MCP client.
#### Example: Claude Desktop Configuration
Add the following to your Claude Desktop configuration file:
```json theme={null}
{
"mcpServers": {
"sensorup": {
"command": "npx",
"args": ["@sensorup/mcp-server"],
"env": {
"SENSORUP_API_KEY": "your-api-key-here",
"SENSORUP_API_URL": "https://api.sensorup.com/graphql"
}
}
}
}
```
### Environment Variables
The SensorUp MCP server requires the following environment variables:
* `SENSORUP_API_KEY`: Your SensorUp API key
* `SENSORUP_API_URL`: The SensorUp GraphQL API endpoint (defaults to production)
## Verification
Once configured, verify the connection by asking your AI assistant to:
1. List available MCP tools
2. Query basic information from your SensorUp account
## Next Steps
* Explore [Available MCP Tools](/api/mcp/tools)
* Review [Usage Examples](/api/mcp/examples)
* Learn about [SensorUp GraphQL API](/api/graphql/overview)
## Troubleshooting
### Connection Issues
If you're experiencing connection issues:
1. Verify your API key is valid
2. Check that your API endpoint URL is correct
3. Ensure your network allows outbound HTTPS connections
4. Review the MCP server logs for error messages
### Authentication Errors
If you encounter authentication errors:
1. Confirm your API key has the necessary permissions
2. Check if your API key has expired
3. See [Authentication](/api/graphql/authentication) for more details
## Support
For additional help, please contact SensorUp support or refer to the [MCP Official Documentation](https://modelcontextprotocol.io).
# MCP Overview
Source: https://docs.sensorup.com/api/mcp/overview
Introduction to the Model Context Protocol (MCP) integration with SensorUp
## What is MCP?
The Model Context Protocol (MCP) is an open protocol that standardizes how applications provide context to Large Language Models (LLMs). MCP enables seamless integration between LLM applications and external data sources and tools.
## SensorUp MCP Integration
SensorUp provides MCP tools that allow AI assistants to interact with your SensorUp data and operations directly. Through MCP, you can:
* Query your asset data
* Access emission event information
* Retrieve operational insights
* Interact with the SensorUp GraphQL API
## Benefits
* **Seamless AI Integration**: Connect AI assistants directly to your SensorUp data
* **Standardized Protocol**: Uses the open MCP standard for broad compatibility
* **Secure Access**: MCP tools use your existing SensorUp authentication
* **Real-time Data**: Access live data from your SensorUp account
## Getting Started
To begin using SensorUp MCP tools, see the [Getting Started](/api/mcp/getting-started) guide.
## Learn More
* [Available MCP Tools](/api/mcp/tools)
* [Usage Examples](/api/mcp/examples)
* [MCP Official Documentation](https://modelcontextprotocol.io)
# Available MCP Tools
Source: https://docs.sensorup.com/api/mcp/tools
Reference guide for SensorUp MCP tools and their capabilities
## Overview
SensorUp provides a set of MCP tools that enable AI assistants to interact with your SensorUp data and operations. Each tool is designed to perform specific tasks using the SensorUp GraphQL API.
## Core Tools
### Query Tool
Execute GraphQL queries against the SensorUp API.
**Capabilities:**
* Read asset data
* Query emission events
* Retrieve operational metrics
* Access user and organization information
**Input Parameters:**
* `query`: GraphQL query string
* `variables`: Optional query variables
**Example Usage:**
Ask your AI assistant: "Query my assets using the SensorUp MCP tool"
***
### Asset Tool
Retrieve and manage asset information.
**Capabilities:**
* List assets
* Get asset details
* Query asset status
* Access asset metadata
**Input Parameters:**
* `assetId`: Optional asset identifier
* `filters`: Optional filters for asset queries
**Example Usage:**
Ask your AI assistant: "Show me all my active assets"
***
### Event Tool
Access emission event data and analytics.
**Capabilities:**
* List emission events
* Get event details
* Query event statistics
* Access event timeline data
**Input Parameters:**
* `eventId`: Optional event identifier
* `dateRange`: Optional date range filter
* `status`: Optional event status filter
**Example Usage:**
Ask your AI assistant: "Show me emission events from the last 30 days"
***
## Data Tools
### Analytics Tool
Retrieve analytical insights and metrics.
**Capabilities:**
* Get summary statistics
* Query trend data
* Access dashboard metrics
* Generate custom reports
**Input Parameters:**
* `metricType`: Type of metric to query
* `dateRange`: Date range for analytics
* `groupBy`: Optional grouping parameter
**Example Usage:**
Ask your AI assistant: "Get emission trends for the last quarter"
***
## Tool Permissions
All MCP tools respect your SensorUp user permissions. Tools can only access data and perform operations that your API key is authorized for.
## Rate Limits
MCP tools are subject to the same rate limits as the SensorUp GraphQL API. See [Performance](/api/graphql/performance) for details.
## Tool Development
SensorUp MCP tools are built on the Model Context Protocol standard. For information about creating custom tools or extending existing ones, refer to the [MCP Official Documentation](https://modelcontextprotocol.io).
## Best Practices
1. **Be Specific**: Provide clear, specific requests to your AI assistant
2. **Use Filters**: Leverage filtering parameters to reduce response sizes
3. **Check Permissions**: Ensure your API key has appropriate permissions
4. **Monitor Usage**: Keep track of your API usage and rate limits
## Related Resources
* [Getting Started](/api/mcp/getting-started)
* [Usage Examples](/api/mcp/examples)
* [GraphQL API Reference](/api/graphql/overview)
* [Authentication](/api/graphql/authentication)
# Introduction to Connected Assets
Source: https://docs.sensorup.com/overview/intro-connected-assets
Discover SensorUp's Connected Assets: Unify, standardize, and visualize emissions data from diverse sources. Build a connected asset registry, apply custom business logic, and integrate seamlessly for proactive emissions management.
# Introduction to Connected Assets
SensorUp's **Connected Assets** module is the foundation of your emissions management strategy, empowering you to harness the power of unified data for smarter asset management. It provides a comprehensive platform to seamlessly integrate data from diverse sources, customize business logic, visualize critical information, and establish a connected asset registry, ensuring precise analysis and informed decision-making across your entire asset portfolio.
> [!NOTE]
>
> Connected Assets ensures all your emissions-related data—from sensors, remote monitoring, or periodic inspections—is harmonized, enabling precise comparisons, comprehensive trend analysis, and a proactive approach to emissions management.
## The Challenge: Siloed & Underutilized Asset Data
Organizations often struggle with asset and emissions data that is:
* **Fragmented:** Data resides in multiple, disconnected systems (SCADA, sensor platforms, inspection tools, spreadsheets).
* **Inconsistent:** Different data formats and lack of standardization hinder effective analysis and comparison.
* **Delayed:** Field data often lags behind operational needs, causing delays in decision-making.
* **Difficult to Contextualize:** Relating disparate data points back to specific assets or operational events can be challenging.
## How Connected Assets Solves This
SensorUp Connected Assets provides a unified solution to:
* **Integrate Multi-Source Data:** Bring together data from a wide variety of measurement sources and existing systems.
* **Standardize Information:** Harmonize data into a consistent format for accurate comparisons and trend analysis.
* **Build a Connected Asset Registry:** Establish a digital twin of your physical assets, including their properties and relationships.
* **Enable Advanced Visualization:** Utilize powerful map and time-series views to interpret, correlate, and act on emissions data.
* **Customize Business Logic:** Define rules and workflows for managing alerts, events, and data processing.
* **Facilitate No-Code Integrations:** Easily connect with other systems in your tech stack for data ingress and egress.
## Core Capabilities of Connected Assets
Connected Assets offers a suite of robust features to transform your raw data into actionable intelligence:
> [accordion] Unified Data Integration & Standardization
>
> Seamlessly bring together and harmonize data from all your relevant sources.
>
> * **Multi-Source Data Ingestion:** Connect to various measurement sources including sensors, SCADA systems, OGI reports, flyovers, and manual inspection data.
> * **Data Harmonization Engine:** Automatically standardizes diverse data formats and units into a consistent structure, enabling accurate comparisons and comprehensive trend analysis.
> * **Real-time Data Synchronization:** Ensures that field data is aligned with central operations, minimizing delays in decision-making (where source systems support it).
> [accordion] Connected Asset Registry
>
> Build and maintain a comprehensive digital representation of your physical assets.
>
> * **Flexible Asset Modeling:** Define and manage various asset types such as facilities, sites, wells, pipelines, platforms, and individual equipment components.
> * **Asset Hierarchy & Relationships:** Establish parent-child and other relationships between assets to accurately model your operational structure and enable contextual analysis.
> * **Customizable Asset Attributes:** Define and track specific properties and metadata for each asset type relevant to your operations and reporting needs.
> [accordion] Advanced Visualization & Analytics
>
> Interpret, correlate, and act on emissions data through powerful visual tools.
>
> * **Interactive Map Views:** Visualize asset locations, sensor readings, and emission events geographically to understand spatial relationships and identify hotspots.
> * **Time Series Analysis:** Plot data over time to identify trends, anomalies, and patterns in emissions or operational parameters.
> * **Correlated Data Views:** Overlay different datastreams (e.g., emissions and operational data) to understand relationships and potential causal factors.
> [accordion] Customizable Business Logic & Alerting
>
> Define and automate responses to specific conditions and events.
>
> * **Rule-Based Event Handling:** Configure specific rules and workflows for managing alerts and events, ensuring timely responses aligned with operational goals.
> * **Automated Notifications:** Set up alerts to notify relevant personnel when predefined thresholds are breached or specific conditions are met.
> * **Workflow Triggering:** Initiate automated workflows or actions based on incoming data or defined business logic.
> [accordion] No-Code & Low-Code Integrations
>
> Easily connect Connected Assets with your broader technology ecosystem.
>
> * **Intuitive Data Ingress:** Configure connections to bring data into Connected Assets from various sources without requiring custom coding.
> * **Flexible Data Egress:** Share standardized and processed asset and emissions data with other enterprise systems (e.g., ERP, Field Service Management, ESG platforms) using no-code interfaces.
## Conceptual Workflow for Leveraging Connected Assets
The following steps outline a general process for utilizing Connected Assets to manage your emissions data:
### 1. 1. Define & Build Your Asset Registry
Identify all relevant physical assets. Use the **Connected Asset Registry** tools to create their digital representations, define types, attributes, and hierarchies within SensorUp.
### 2. 2. Integrate Data Sources
Connect your various data sources (sensors, SCADA, inspection tools, etc.) using **Multi-Source Data Ingestion** capabilities, including no-code connectors where applicable. Data is then standardized by the **Data Harmonization Engine**.
### 3. 3. Configure Business Logic & Alerts
Define rules for how incoming data should be processed. Set up **Customizable Business Logic** for alerts, event triggers, and notifications based on thresholds or specific data patterns.
### 4. 4. Visualize & Analyze Data
Utilize **Advanced Visualization Tools** (map views, time series charts) to monitor asset performance, analyze emission trends, and correlate different datastreams for deeper insights.
### 5. 5. Act on Insights & Share Data
Based on analysis and alerts, initiate operational responses or further investigations. Use **No-Code Integrations** to share enriched and contextualized data with other enterprise systems for broader operational use or reporting.
## Key Benefits of Using Connected Assets
* **Single Source of Truth:** Consolidate all asset-related emissions data into one harmonized platform.
* **Enhanced Data Accuracy & Consistency:** Standardization eliminates discrepancies from diverse data formats.
* **Improved Decision-Making:** Real-time data (where available) and advanced visualizations provide actionable insights.
* **Increased Operational Efficiency:** Automated alerts and streamlined data access reduce manual effort.
* **Greater Value from Existing Tech:** Seamlessly integrates with and enhances your current technology investments.
* **Proactive Emissions Management:** Enables early detection of anomalies and trends for timely intervention.
> [!TIP]
>
> With Connected Assets, you gain unparalleled control and visibility over your emissions data, transforming it from a complex challenge into a strategic asset.
## Next Steps
To maximize your use of Connected Assets:
> [card] [Getting Started with Assets](/use-sensorup/assets/getting-started)
>
> Learn how to set up and manage your asset registry and hierarchies.
> [card] [Asset Technical Specifications](/use-sensorup/assets/assets-model)
>
> Detailed documentation on the asset data model and technical specifications.
# Introduction to Connected Markets
Source: https://docs.sensorup.com/overview/intro-connected-markets
Discover SensorUp's Connected Markets: Streamline emissions data management, ensure regulatory compliance (GHGRP, OGMP 2.0), simplify market participation (Veritas), and perform robust emissions accounting.
# Introduction to Connected Markets
SensorUp's **Connected Markets** module is your central hub for driving compliance and achieving success in both regulatory and voluntary emissions markets. It integrates cutting-edge data management and reporting capabilities to streamline adherence to stringent frameworks like GHGRP and OGMP 2.0, simplify your participation in environmental initiatives such as Veritas, and ensure your emissions accounting is accurate and audit-ready.
> [!NOTE]
>
> Connected Markets empowers your technical teams to proactively manage compliance, mitigate risks, and enhance transparency across all reporting activities by centralizing and reconciling emissions data.
## The Challenge: Navigating Complex Market & Regulatory Demands
Organizations face significant hurdles in managing emissions data for compliance and market participation:
* **Diverse Reporting Requirements:** Meeting the specific needs of multiple regulatory bodies (e.g., GHGRP) and voluntary programs (e.g., OGMP 2.0, Veritas) is complex.
* **Data Aggregation & Validation:** Consolidating data from various systems and ensuring its accuracy is time-consuming.
* **Reconciliation & Discrepancies:** Aligning bottom-up (source-level) and top-down (site-level) inventories requires sophisticated tools.
* **Maintaining Auditability:** Ensuring all data, calculations, and adjustments are traceable is paramount.
## How Connected Markets Solves This
SensorUp Connected Markets provides a unified solution to:
* **Centralize Reporting Data:** Act as the nexus for all market-related data inputs.
* **Streamline Compliance Workflows:** Configure and manage processes according to specific regulatory and voluntary program needs.
* **Facilitate Market Participation:** Provide real-time insights and ensure data meets standards for initiatives like OGMP 2.0 and Veritas.
* **Enable Robust Data Reconciliation:** Integrate various data sources to calculate and reconcile bottom-up and top-down inventories.
* **Support Effective Accounting Processes:** Implement collaborative workflows for emissions data management.
## Core Capabilities of Connected Markets
Connected Markets offers a suite of powerful features to manage your emissions reporting and market interactions:
> [accordion] Centralized Reporting Hub
>
> Serves as the primary platform for all emissions data related to market participation and regulatory reporting.
>
> * **Multi-Source Data Aggregation:** Ingests and consolidates data from emissions monitoring devices, SCADA, manual inputs, third-party sources, and other enterprise systems.
> * Standardized data intake normalizes diverse formats.
> * A validation engine checks data quality and adherence to standards.
> * **Unified Emissions Inventory:** Creates a comprehensive view of emissions across all assets and sources, including historical data management.
> [accordion] Compliance & Market Program Management
>
> Tools and workflows to manage and streamline adherence to various reporting requirements.
>
> * **OGMP 2.0 Reconciliation & Reporting:**
> * Facilitates yearly reconciliation of site-level and source-level inventories.
> * Highlights discrepancies and incorporates associated uncertainties for each inventory type.
> * Analyzes contributions from different source categories (stationary combustion, tank venting, fugitives).
> * Aims for congruence between bottom-up and top-down estimates when accounting for uncertainty.
> * Integrates site-level measurements (CMS, drones, flyovers) directly into the workflow to improve data quality and attribute emissions.
> * **Veritas-Compatible Reconciliation:**
> * Supports monthly emissions reconciliation aligned with Veritas principles.
> * Provides a dashboard showing total reconciled emissions, site statuses (open, in progress, closed), methane intensity, and production numbers.
> * Allows drilldown into site-level, day-by-day reconciled emissions, identifying sources and applied rule sets (e.g., Veritas One rule set).
> * Incorporates business processes like operator decisions, automated rule execution, error handling, and peer review submissions.
> * **GHGRP Reporting Support:** Assists in preparing data and generating reports compliant with Greenhouse Gas Reporting Program requirements.
> * **Customizable Compliance Workflows:** Allows setup of reporting processes with task management, approvals, and comprehensive audit trail generation.
> [accordion] Flexible Data Reconciliation & Accounting
>
> Advanced capabilities for integrating, reconciling, and accounting for emissions data.
>
> * **Bottom-up / Top-down Reconciliation Engine:** Enables the calculation and alignment of inventories derived from source-level estimates and site-level measurements.
> * Includes tools for discrepancy analysis and uncertainty quantification.
> * **SensorUp Carbon Calculator:** A low-code, configurable tool for arithmetic-based emissions calculations.
> * **Observation Workflow:** Inspect incoming datastream records (e.g., CO2e per day) on a monthly basis, view charts, and apply common data correction approaches.
> * **Data Snapshotting:** Fixes data for a specific reporting period to ensure calculation consistency.
> * **Custom Calculation Builder:** Define formulas for metrics like methane intensity, CO2e, reconciliation adjustments, CDR credit generation, considering LCA boundaries and calculation nodes.
> * **Effective Accounting Processes:** Supports collaborative workflows, peer review mechanisms, and streamlined month-end close for emissions data.
## Conceptual Workflow for Emissions Reconciliation & Reporting
The following steps illustrate a general process within Connected Markets, adaptable for frameworks like OGMP 2.0 and Veritas:
### 1. 1. Data Aggregation & Inventory Setup
Centralize all relevant data: bottom-up source-level estimates, top-down site-level measurements (flyovers, CMS, satellite), and operational data like production figures.
### 2. 2. Framework-Specific Reconciliation
* **For OGMP 2.0 (Yearly):** Compare site-level and source-level inventories. Analyze discrepancies and uncertainties. Drill into source categories and incorporate site-level measurements to refine data and aim for congruence between inventories when uncertainty is accounted for.
* **For Veritas (Monthly):** Review reconciled emissions dashboard. Drill into sites for day-by-day breakdowns. Apply Veritas rule sets and manage operator decisions for reconciliation.
### 3. 3. Data Correction & Calculation (Carbon Calculator)
Inspect detailed datastream records (e.g., daily CO2e). Apply data corrections. Create a "snapshot" to fix data for the reporting period. Run configured calculations for methane intensity, CO2e, etc.
### 4. 4. Review, Approvals & Finalization
Utilize built-in business processes for internal review, peer approval, and finalization of reconciled data and calculations.
### 5. 5. Report Generation & Export
Generate reports formatted for specific regulatory bodies (GHGRP, OGMP 2.0) or voluntary programs (Veritas). Export data for submissions or to monitoring dashboards.
## Key Benefits of Using Connected Markets
* **Streamlined Compliance:** Simplify adherence to complex frameworks like OGMP 2.0, GHGRP, and Veritas.
* **Improved Accuracy:** Rigorous reconciliation processes and uncertainty management lead to more reliable emissions figures.
* **Actionable Insights:** Understand discrepancies between inventory types and pinpoint areas for data quality improvement.
* **Enhanced Auditability:** Maintain a clear record of data inputs, calculations, decisions, and rule applications.
* **Flexible Calculations:** The Carbon Calculator allows for tailored accounting methodologies.
> [!TIP]
>
> SensorUp Connected Markets utilizes all available data types to prioritize and produce the most accurate estimates for robust emissions reconciliation and reporting.
## Next Steps
To delve deeper into the capabilities of Connected Markets:
> [card] [Solutions for Simplifying OGMP](/solutions/enterprise-solutions/solutions-for-simplifying-ogmp)
>
> Learn how SensorUp simplifies OGMP 2.0 reporting and reconciliation.
> [card] [Integrated Emission Management](/solutions/enterprise-solutions/integrated-emission-management-solution)
>
> Explore our comprehensive solution for emissions management and reporting.
# Introduction to Connected Operations
Source: https://docs.sensorup.com/overview/intro-connected-operations
Learn how SensorUp's Connected Operations seamlessly integrates emission management with field service actions, streamlining workflows from detection to OGI inspection and repair verification using SensorUp Outpost.
# Introduction to Connected Operations
SensorUp's **Connected Operations** module bridges the critical gap between emission management and follow-up field service actions. It enables a seamless flow of information, allowing operators to review detections from various sources (flyovers, drones, CMS) within the emission management system and initiate actions like an OGI inspection, which then flows directly to field personnel using **SensorUp Outpost**, our mobile field application.
> [!NOTE]
>
> Connected Operations enhances responsiveness, improves data accuracy, and ensures regulatory compliance by creating a cohesive, automated workflow from initial detection to field verification and repair.
## The Challenge: Disconnected Detection and Field Action
Traditionally, acting on an emission detection often involves manual handoffs between office-based emission managers and field service teams:
* Emission detected and analyzed in one system.
* Separate communication (email, phone call) to request a field inspection.
* Field data collected on paper or in a different mobile app.
* Manual data entry back into the primary system.
This disconnected process can lead to delays, data entry errors, and difficulty tracking the status of follow-up actions, ultimately impacting the speed of emission mitigation.
## How Connected Operations Solves This
SensorUp Connected Operations streamlines this by:
* **Integrated Action Initiation:** Directly create work orders (e.g., OGI inspection requests) from an emission event within the main platform.
* **Seamless Data Flow to Mobile:** Work orders and relevant event details are automatically pushed to field operators via the SensorUp Outpost mobile app.
* **Standardized Field Data Capture:** Field personnel use structured forms in Outpost to record findings, verify leaks, and document repairs, ensuring consistency (e.g., aligned with BCER, AER requirements).
* **Real-time Synchronization:** Data captured in Outpost (including photos, annotations, and form submissions) syncs directly back to the emission event in the central platform.
* **Automated Event Updates:** Actions in the field, like repairing a leak, can automatically update the emission event's status and end date.
## The Connected Operations Workflow: OGI Inspection Example
Let's walk through a typical workflow where an emission detection triggers an OGI inspection request, managed through Connected Operations and SensorUp Outpost.
**1. 1. Identify Need for Field Verification**
Within the **Emission Ops** module, an air quality manager or operator reviews detections (from flyovers, drones, CMS, etc.).
* If an emission event requires ground-level verification, the operator decides to initiate an OGI inspection.
**2. 2. Create Work Item**
From the emission event details page:
* The operator clicks an "Action" button and select a work item like "OGI Inspection."
* A dialog appears, often pre-populating relevant details from the emission observation (e.g., location, initial detection data).
* **Notification (Optional):** The operator can enter email addresses in a "Send To" section to notify relevant stakeholders that an inspection has been requested.
> [!NOTE]
>
> This action creates a new work item linked to the emission event.
**3. 3. Track Work Item Progress**
Back in the emission event details on the main platform, a "Work Item" section appears.
* This section allows office personnel to track the progress of the OGI inspection (e.g., "Assigned," "In Progress," "Completed").
**4. 4. Field Operator Receives Task in SensorUp Outpost**
The Work Item, along with associated emission event details, appears in the SensorUp Outpost mobile app for the assigned field technician.
* The technician can review the task details and prepare for the site visit.
**5. 5. On-Site Data Capture with Outpost**
At the site, the field operator uses SensorUp Outpost:
* **Site Check-in:** Completes any required site check-in forms.
* **Record Leaks/Vents:** If a leak is found during the OGI survey, the operator uses the "+" button to record new leaks or verify existing ones.
* **Standardized Forms:** Uses digital forms (e.g., designed to meet EPA, BCER or AER requirements) to document observations, leak details, component types, etc.
* **Capture Visual Evidence:** Uses the camera feature within Outpost to take pictures or upload photos from their device. They can annotate these images directly in the app.
**6. 6. Complete & Submit Inspection Survey**
Once the Work Itemis complete and all findings are documented (e.g., leaks identified, components checked):
* The operator completes the Work Item in Outpost.
* All data, including forms, photos, and annotations, is submitted and synchronizes back to the central SensorUp platform.
**7. 7. Review Field Data in Emission Event**
Back in the main platform's emission event details:
* The Work Item status updates to "Completed."
* Office personnel can now review the newly collected data from the field, including detailed leak information, photos, and any findings from the inspection report.
**8. 8. Emission Event Auto-Update & Closure**
* **Automatic Updates:** If a leak is documented as repaired and verified in Outpost, this information syncs back. The emission event in the central platform can be configured to automatically update its end date based on the repair verification. This ensures accurate tracking of the event's duration.
* **Event Closure:** Once the leak is confirmed repaired and all necessary documentation is complete, the operator can confidently close the emission event, completing the workflow and maintaining a full audit trail for compliance.
## Key Benefits of Connected Operations
* **Improved Responsiveness:** Faster transition from detection to field action.
* **Enhanced Data Accuracy:** Standardized digital forms and direct data sync reduce manual entry errors.
* **Full Audit Trail:** Complete, end-to-end record of detection, inspection, findings, and resolution.
* **Streamlined Compliance:** Easier to demonstrate due diligence and adherence to regulatory requirements (e.g., LDAR programs).
* **Increased Efficiency:** Automated workflows reduce manual handoffs and administrative burden.
* **Empowered Field Teams:** SensorUp Outpost provides field operators with the information and tools they need to perform their tasks effectively.
> [!TIP]
>
> By connecting detections directly to field inspections through a simple, automated workflow, SensorUp Connected Operations significantly improves responsiveness, data accuracy, and regulatory compliance.
## Next Steps
To learn more about leveraging Connected Operations and SensorUp Outpost:
> [card] [Using SensorUp Outpost (Mobile App)](/use-sensorup/outpost-mobile/overview)
>
> A detailed guide for field operators on using the Outpost app for various inspection types and data capture.
> [card] [Connected Operations OGI Workflow](/use-sensorup/connected-operations/connected-operations-ogi-workflow)
>
> Learn about the end-to-end workflow for OGI inspections and field operations.
# Introduction to SensorUp
Source: https://docs.sensorup.com/overview/intro-sensorup-platform
Discover SensorUp, a configurable emissions management platform designed to integrate your data, streamline operations, ensure compliance, and accelerate your journey to significant emissions reduction.
# Introduction to SensorUp: A Configurable Emissions Management Platform
Welcome to SensorUp! We provide an enterprise-grade, **configurable emissions management platform** designed to help organizations like yours tackle the most pressing emissions challenges and **drive significant reduction at scale**. Our platform integrates your diverse data sources, streamlines complex workflows, and provides the actionable insights needed to achieve your sustainability and operational excellence goals.
> [!NOTE]
>
> SensorUp empowers you to move beyond siloed data and manual processes, offering a unified, adaptable solution that accelerates your emissions reduction journey.
## The Challenge: Managing Emissions in a Complex Landscape
Effectively managing and reducing emissions presents numerous hurdles:
* **Data Overload & Silos:** Data from sensors, inspections, operational systems, and third-party feeds is often voluminous, disparate, and difficult to consolidate for a holistic view.
* **Evolving Regulations & Market Demands:** Keeping pace with complex, changing compliance requirements (GHGRP, OGMP 2.0, Veritas) and voluntary market standards is a constant effort.
* **Operationalizing Insights:** Translating raw data into actionable steps for field teams, operational adjustments, and strategic decisions can be slow and inefficient.
* **Scaling Reduction Efforts:** Moving from pilot projects to enterprise-wide emissions reduction requires robust, scalable systems and processes.
* **The "Build vs. Buy" Dilemma:** Developing a comprehensive, in-house emissions management solution is a massive undertaking, requiring significant time, specialized expertise, ongoing maintenance, and can divert focus from core business activities.
## The SensorUp Solution: Configuration & Integration at Scale
SensorUp addresses these challenges by providing a **configurable platform**, not a rigid, one-size-fits-all product. We understand that each organization has unique assets, operational workflows, and reporting needs. Our approach combines the power of a specialized, off-the-shelf platform with the flexibility to adapt to your specific environment.
**Key Pillars of Our Approach:**
1. **Unified Data Foundation (Connected Assets):** We start by helping you integrate and contextualize all your asset-related data, creating a single source of truth. (See [Introduction to Connected Assets](/overview/intro-connected-assets))
2. **Streamlined Action & Workflow (Connected Operations):** We connect emission insights directly to field service actions and operational responses, automating and optimizing your workflows. (See [Introduction to Connected Operations](/overview/intro-connected-operations))
3. **Assured Compliance & Market Readiness (Connected Markets):** We provide the tools for robust reconciliation, accurate reporting, and confident participation in regulatory and voluntary markets. (See [Introduction to Connected Markets](/overview/intro-connected-markets))
By integrating these pillars, SensorUp enables a continuous cycle of measurement, analysis, action, and reporting, all geared towards scalable emissions reduction.
## Why Choose a Configurable Platform like SensorUp?
When considering how to tackle emissions management, the "build vs. buy" question is critical. Building a custom solution from scratch is resource-intensive and carries significant risk. SensorUp offers the advantages of a specialized platform while providing the configurability you need:
> [accordion] Accelerate Time-to-Impact & Reduction
>
> Leverage a feature-rich platform built on years of emissions management expertise. Instead of spending 12-24+ months building a foundational system, you can start configuring SensorUp to your needs and seeing results much faster, accelerating your progress towards reduction targets.
> [accordion] Focus on Your Core Mission, Not Software Development
>
> Your expertise lies in your core operations, not in building and maintaining complex enterprise software for emissions. SensorUp handles the underlying platform architecture, data models, security, scalability, and ongoing evolution, allowing your teams to focus on what they do best: reducing emissions and optimizing operations.
> [accordion] Benefit from Deep Domain Expertise & Best Practices
>
> SensorUp is built with deep knowledge of emissions sources, regulatory frameworks (OGMP 2.0, GHGRP, Veritas), data standards (ISO 19156:2023), and industry best practices. This expertise is embedded in our platform, saving you the effort of acquiring and maintaining it internally.
> [accordion] Achieve True Scalability & Future-Proofing
>
> Our platform is designed to scale with your needs, from managing a few assets to tens of thousands, and handling increasing data volumes from diverse sources. We continuously update SensorUp to incorporate new technologies, integrate with emerging data providers, and adapt to evolving regulatory landscapes, future-proofing your investment.
> [accordion] Harness the Power of Configuration, Not Custom Code
>
> "Configurable" means you can tailor SensorUp to your specific asset hierarchies, data source schemas, business rules, workflows, and reporting formats primarily through setup and configuration UIs, low-code tools, and well-defined APIs—without extensive custom software development for every need. This provides flexibility while retaining the benefits of a standardized, supported platform.
> [accordion] Comprehensive Integration Capabilities
>
> A major challenge in any emissions program is integrating data. SensorUp is designed for this, offering multiple pathways – from low-code connectors to direct data feeds (S3, SFTP) and managed integrations – to connect your existing systems and new data sources efficiently. (See [Getting Started with Integrations](/use-sensorup/user-management/getting-started-integrations))
## Core Platform Modules at a Glance
SensorUp's configurable power is delivered through its integrated modules:
> [card] [Connected Assets](/overview/intro-connected-assets)
>
> Unify, standardize, and visualize all your asset and emissions data. Build a comprehensive asset registry as the foundation for accurate tracking and analysis.
> [card] [Connected Operations](/overview/intro-connected-operations)
>
> Streamline workflows from methane detection to field verification and repair. Automate actions and connect office insights with field activities seamlessly.
> [card] [Connected Markets](/overview/intro-connected-markets)
>
> Manage compliance with OGMP 2.0, GHGRP, Veritas, and other programs. Perform robust data reconciliation and generate accurate reports for all stakeholders.
## Who Benefits from SensorUp?
Our platform is designed to support various roles within your organization:
* **Operators & Field Teams:** Streamlined workflows, mobile tools, and clear actions.
* **Air Quality, ESG & Environmental Managers:** Comprehensive data, robust reporting, and tools for compliance and reduction strategy.
* **IT & Systems Integrators:** Flexible integration options, standardized data models, and a scalable architecture.
* **Leadership & Strategy Teams:** Actionable insights for data-driven decisions and progress tracking towards sustainability goals.
## Navigating This Documentation
These documents are designed to help you understand and effectively use the SensorUp platform:
* **Introductions:** High-level overviews of SensorUp and its core modules.
* **Getting Started Guides:** Practical steps for initial setup, data integration, and key workflows.
* **Feature Guides:** In-depth explanations of specific functionalities within each module.
* **API Reference:** Technical details for developers using our GraphQL API.
We are excited to partner with you on your emissions reduction journey!
# Welcome to SensorUp Documentation
Source: https://docs.sensorup.com/overview/overview
Explore SensorUp's emissions management platform. Find guides, feature explanations, and best practices for operators, air quality teams, and IT professionals.
# Welcome to SensorUp Documentation
SensorUp provides a comprehensive enterprise platform designed to tackle the most pressing emissions challenges in the oil and gas sector. These documents offer in-depth information on our solutions—Connected Assets, Connected Operations, and Connected Markets—to help you effectively manage emissions, ensure compliance, and achieve your sustainability goals.
> [!NOTE]
>
> Our platform helps you stay connected to your assets, operations, and markets, transforming complex data into actionable insights for emission management excellence.
## Explore Our Platform
Dive into the core components of the SensorUp Enterprise Platform. Each section provides detailed information on features, capabilities, and how to leverage them for optimal emissions management.
> [card] [Introduction to SensorUp Platform](/overview/intro-sensorup-platform)
>
> Discover SensorUp's configurable emissions management platform designed to integrate your data, streamline operations, ensure compliance, and accelerate your journey to significant emissions reduction.
> [card] [Introduction to Connected Assets](/overview/intro-connected-assets)
>
> Learn to unify, standardize, and visualize emissions data from diverse sources. Build a connected asset registry and apply custom business logic for proactive emissions management.
> [card] [Introduction to Connected Operations](/overview/intro-connected-operations)
>
> Discover how to seamlessly integrate emission management with field service actions, streamlining workflows from detection to OGI inspection and repair verification.
> [card] [Introduction to Connected Markets](/overview/intro-connected-markets)
>
> Understand how to streamline emissions data management, ensure regulatory compliance (GHGRP, OGMP 2.0), simplify market participation (Veritas), and perform robust emissions accounting.
# Third-party data notices
Source: https://docs.sensorup.com/overview/third-party-data-notices
Third-party data used by SensorUp Studio and the licences it is provided under.
This page lists third-party data used by SensorUp Studio and the licences it is provided under.
## Timezone boundaries
Timezone lookup contains information from timezone-boundary-builder ([https://github.com/evansiroky/timezone-boundary-builder](https://github.com/evansiroky/timezone-boundary-builder)), which is made available under the Open Database License (ODbL) ([https://opendatacommons.org/licenses/odbl/1-0/](https://opendatacommons.org/licenses/odbl/1-0/)). Boundary data © OpenStreetMap contributors.
# Oct, 7 2025
Source: https://docs.sensorup.com/releases/2025-10-07
This release includes the Asset Change Audit History and Permanent Asset Deletion features, offering enhanced control, transparency, and auditability over their asset data. Additionally, the mobile app experience was enhanced to streamline workflows for field operators and improve the app's stability.
## 🚀 New Features
These new capabilities provide significant value and expanded functionality:
* **Asset Change Audit History:** You can now view a complete history of changes to assets. This provides greater transparency and traceability for all modifications to your asset data.
* **Permanent Asset Deletion for Super Admins:** A secure, two-step process has been implemented that allows Super Admins to permanently delete an asset after it has been archived. This ensures data retention policies can be met while preventing accidental deletion of active assets.
* **Initiate Mobile Follow-Up Actions from Site Summary:** Users can now initiate follow-up actions directly from the site summary on Android devices.
## ✨ Minor Enhancements
These improvements refine existing features and enhance your day-to-day workflow:
* **Configurable Columns for Emission Observations:** You can now configure the columns on the Emission Observations page to show all schema fields.
* **Improved Mobile Site Summary UI (iOS & Android):**
* The tap target for the site summary has been enlarged on both iOS and Android, making it easier to navigate.
* Category labels have been updated for clarity (e.g., "Outstanding leaks" is now "Leaking") and status naming has been unified ("Repaired + Verified" is now "Repaired").
* **Enhanced Asset Table Experience:**
* A default column view is now available for the asset page, providing a consistent starting point before user customization.
* The attribution modal now fetches asset children without causing the top-level attribution to disappear.
* **Streamlined Mobile Login Experience (iOS):**
* Users now have an improved experience for handling server input errors during login.
* Users can easily navigate back from the username/password screen to the server selection view.
* **Carbon Claim Details Update:** The "Claim URI" field has been added to the Claim Details section in the UI.
* **Carbon Accounting Dashboard Screen Updates:** New carbon accounting dashboard metrics have been added, including total credits generated, capture, transport, and storage, along with new graphs.
## 🐞 Bug Fixes
We've squashed several bugs to improve the stability and reliability:
* **Corrected Data and Image Display:**
* Fixed a bug where the top-level asset attribution would disappear after fetching child assets.
* **UI and Navigation Fixes:**
* Corrected the horizontal scroll behavior on the Heatmap and replaced the custom no-data component with the standard one.
* Fixed a bug on Android tablets where rotating the screen on the site summary page would incorrectly redirect the user.
* **Data Integrity and Performance:**
* Fixed a bug where some newly imported CMS detections were being automatically closed without an end time defined.
* Resolved an issue preventing the creation of an observation from the leak detail view before a Site Check-in was completed on iOS.
## ⚙️ Under the Hood Improvements
These improvements enhance the performance, reliability, and scalability of the platform, laying groundwork for future advancements:
* **AI Feature Foundation:**
* Created the foundational infrastructure for upcoming AI micro-features, including a shared BaseAIService class, reusable React components, and shared GraphQL hooks.
* **Mobile Architecture & Testing:**
* Re-architected the Flutter module for the SensorHub iOS app to use a cleaner, faster, and more maintainable system.
* Completed testing and configuration to ensure solutions work for mobile, including LaunchDarkly flags and backend compatibility.
* **Database and Backend Logic:**
* Developed a base data source class that wraps a Postgres table to streamline querying for reading and writing entities.
* Optimized soft-delete performance by removing a backend check.
# Nov, 21 2025
Source: https://docs.sensorup.com/releases/2025-11-21
This release focuses on LDAR + Emissions Ops Efficiency and Outpost Mobile Application improvements. Teams can now process multiple emission events simultaneously with new bulk actions, while mobile users benefit from enhanced form validation and improved app stability. We've also advanced our API integration capabilities and resolved critical bugs affecting data accuracy across both platforms.
## Web Application
### 🚀 Features
* **Bulk Actions for Emission Events** - Process multiple emission events at once with new bulk capabilities for marking false alarms, closing events, and correlating detections. This streamlines workflows and reduces the time needed to manage large volumes of emission events.
* **Edit Manually Created Emission Observations** - Update all fields of manually created emission observations after initial creation. All changes are tracked in the observation history, giving editors and admins full flexibility to refine data as needed.
* **One-Click Coordinate Copying** - Quickly copy latitude and longitude coordinates from the emission events table and emission observation details blade with a single click, making it easier to share location data with field teams or integrate with other tools.
* **Customizable View Options** - Toggle between map, timeline, and table views to focus on the information most relevant to your workflow. Hide or show different panels based on your current task.
* **Simplified Asset Update Page** - Removed unnecessary fields from the asset update page to streamline the asset management workflow.
* **Year Added to Issue Request Emails** - Issue request emails now include the year in the detection date to prevent confusion, especially for historical detections.
### 🐞 Bugs
* **Fixed Asset Attribution Error** - Resolved an issue where follow-up requests were displaying the wrong asset. The system now correctly uses the emission event's asset reference to ensure accurate attribution.
* **Fixed User Attribution in Observation History** - Corrected an issue where emission observation updates showed "system" instead of the actual user's name in the audit history.
* **Resolved Emission Events Table Loading Error** - Fixed a critical error that prevented the emission events table from loading properly.
* **Fixed Timeline Visualization Error** - Corrected an issue that caused timeline views to fail when loading state-based data.
* **Fixed Map Layer Rendering Error** - Resolved a critical error that prevented map layers from rendering correctly.
## Mobile App
### 🚀 Features
* **Auto-Scroll to Form Errors** - When submitting a form with errors or missing required fields, the app now automatically scrolls to the first error, helping users quickly identify and fix issues.
* **Enhanced Download Progress Visibility** - Improved the resource download experience with detailed progress indicators showing both individual resource downloads and overall progress, preventing users from thinking the app has frozen.
### 🐞 Bugs
* **Fixed Observation Timestamp Display (iOS)** - Added missing timestamps to observation cells for better data tracking and visibility.
* **Improved Asset Search Zoom (iOS)** - Enhanced the zoom level when searching for assets on the main map, making it easier to locate specific assets in the field.
# Dec 10, 2025
Source: https://docs.sensorup.com/releases/2025-12-10
This release includes various improvements and bug fixes across the platform.
## Web Application
### 🚀 Features
* **Toggle Observations, Events** - Users can now easily switch between viewing individual observations and grouped emission events. This provides greater flexibility in analyzing emission data.

* **Enhanced Asset Event Table** - The Emission Events table now displays relevant asset properties for all attributed sources. This enhancement provides a more comprehensive view of your asset's emission data directly within the table.

* **API Creates Follow-Up Tasks** - The Issues API can now create follow-up tasks when additional work is required. This allows external systems to seamlessly create actionable items within SensorUp.
### 🐞 Bugs
* **Fixed Form Prefill** - We resolved an issue where forms were not correctly pre-filling from emission observations. This ensures accurate and efficient data entry.
* **Filter Future Emission Events** - The time filter on the Emissions page now supports filtering for events with future dates. This provides greater flexibility in planning and forecasting emission activities.
## Mobile App
### 🚀 Features
* **Mobile User Prefill** - Mobile forms now support pre-filling with the current user's information. This streamlines data entry and improves the mobile user experience.
* **Improved Site Summary** - We have enhanced the Site Summary view for better clarity and usability. This update provides a more intuitive overview of site-specific data.
### 🐞 Bugs
* **Fixed Submit Button Issue** - We fixed an issue where tapping the submit button during animation could lead to an invalid state. This ensures a smoother and more reliable submission process.
# Jan 26, 2026
Source: https://docs.sensorup.com/releases/2026-01-21
This release includes various improvements and bug fixes across the platform.
## Web Application
### 🚀 Features
* **View Event Short ID** - Users can now see the short ID for each Emission Event directly in the UI table. This makes it easier to quickly identify and reference specific events.

* **Delete Open Issues** - Users can now delete open issues and their associated sub-tasks. This provides greater control over managing and cleaning up your issue list.

* **Track External Observations** - We've added external IDs to observations. This enhancement improves data correlation and overall system stability for your observations.
* **Remember Event Grouping** - The 'Group by Event' toggle now persists across user sessions. This ensures a consistent view of your data, saving you time and effort.
* **Request Event Issues** - You can now request issues directly from Emission Events, with email notifications sent to relevant parties. This streamlines communication and follow-up for event-related issues.
* **Add Issue Collaborators** - The issue creation modal now allows you to add collaborators. This facilitates teamwork and ensures everyone is informed about new issues.

* **Correct Volume Calculation** - Volume calculations now correctly return 0 when the duration is 0, instead of an undefined value. This ensures more accurate data reporting.
* **Improved Issues Table** - The Issues table has been updated for improved performance and user experience. You'll notice a smoother and more responsive interface.
* **View Site Summaries** - The 'Site Check' view has been replaced with a new 'Site Summary' roll-up view. This provides a more comprehensive overview of your site data.

* **Filter Observations by Type** - You can now filter Emission Observations and Datasets by Detection Type. This allows you to see all relevant observations in a single, consolidated view.

* **Add Methane Density Option** - Users can now configure methane density settings directly from the User Preference Page. This enhancement provides greater control over emissions calculations and data accuracy.

### 🐞 Bugs
* **Group Follow-up Issues** - Follow-up issues are now automatically created with the correct group assignment. This ensures better organization and tracking of related issues.
* **Fixed Observation Times** - The display of Emission Observation start and end times has been corrected. This ensures that timestamps accurately reflect the data without affecting other related information.
* **Handle Deleted Issues** - Emission Events and Observations now correctly reflect the status of deleted issues and work items. This ensures data consistency across the platform.
* **Transform Plume Images** - The platform now utilizes plume metadata from the data source to intelligently transform plume images on the map. This ensures more accurate and contextually relevant visualization of emission plumes.
## Mobile App
### 🚀 Features
* **View Mobile Observations** - Mobile users can now view detailed Emission Observation information, including all associated data. This provides comprehensive insights on the go.
* **Add Radio Buttons** - The Form Designer now includes radio buttons with conditional branching capabilities. This allows you to create more dynamic and intelligent forms.
# Jan 29, 2026
Source: https://docs.sensorup.com/releases/2026-01-29
## Asset Performance Improvements
We migrated our operational asset data layer from DynamoDB to PostgreSQL. Asset interactions now load in under 1 second, reduced from 8+ seconds.
### Changes
* **Assets page** — Asset inventory loads immediately.
* **Asset hierarchy** — Parent-child relationships display instantly when selecting a site, well, or equipment.
* **Emission event attribution** — Asset search and selection is now responsive during attribution workflows.
* **Nearby assets** — Assets near an emission event load without delay.
# Feb 11, 2026
Source: https://docs.sensorup.com/releases/2026-02-11
This release delivers emissions workflow improvements including plume layer controls, gas conversion preferences, and detection date visibility. Multiple bug fixes address data table reliability, email rendering, and inspection workflows across web and mobile platforms.
## Web Application
### 🚀 Features
* **Toggle Plume Layers** - Users can now toggle plume layers on and off directly from the emissions map, making it easier to focus on specific emission sources without visual clutter.
* **Gas Conversion Preferences** - New preferences allow users to configure gas conversion standards and models, ensuring calculated emission rates match your organization's methodology.
* **Detection Date Columns** - The Emissions page now includes Oldest Detection Date and Newest Detection Date columns, providing clearer visibility into detection timelines across your sites.
* **Sort Issue Comments** - The Comments column in the Issue Gallery now supports sorting, making it easier to find and manage issues based on comment activity.
### 🐞 Bugs
* **Improved Table Pinning** - Fixed an issue where column pinning was not working correctly in data tables. Pinned columns now persist as expected.
* **Fixed Inspection Tab Loading** - Resolved an issue where the Inspection tab would not display data until a filter was changed or the user navigated away and back.
* **Fixed Email Rendering** - Enhanced HTML sanitization for email templates ensures that special characters and measurement values display correctly in notification emails.
* **Fixed Follow-Up Actions** - Resolved an issue where follow-up actions were not creating the expected asset records, which prevented leak statuses from transitioning correctly.
* **Improved Drone Requests** - The drone inspection request workflow has been updated to use a more reliable mechanism, resolving intermittent issues when creating inspection requests.
* **Fixed Outlook Email Scaling** - Resolved an issue where email text would shrink in Microsoft Outlook when images were attached, improving readability across all email clients.
* **Fixed Asset Property Filters** - Asset property level filters now persist when navigating to an asset detail view and returning. Filters no longer disappear unexpectedly.
* **Fixed Event Status Updates** - The Emission Event detail panel now correctly updates its status indicator after an inspection request is created.
* **Android App Stability** - Addressed multiple issues reported during user acceptance testing for the latest Android app version, improving overall stability.
## Mobile App
### 🚀 Features
* **Emission Observation Images** - Mobile users can now view Emission Observation images, including flyover plume imagery, directly within the mobile app for better field context.
# Mar 9, 2026
Source: https://docs.sensorup.com/releases/2026-03-09
This release introduces a unified follow-up action modal, bulk issue deletion, and pinned table columns in the web application. Android mobile users benefit from a redesigned offline sync mechanism and improved performance on issue detail screens. Several bug fixes address event filtering, table display, and form rendering issues.
## Web Application
### 🚀 Features
* **Unified Follow-Up Requests Modal** - Combined all follow-up action types into a single, streamlined modal for faster event resolution workflows.
* **Pinned Table Columns** - ID and Type columns are now pinned to the left side of emission event and observation tables, keeping key identifiers visible while scrolling horizontally.
* **Bulk Delete for Issues** - Users can now select and delete multiple open issues and sub-tasks at once, reducing manual cleanup time.
### 🐞 Bugs
* **Fixed Event Filtering** - Resolved an issue where emission event filters would not apply correctly when using asset property criteria.
* **Fixed Table Selection** - Corrected a display issue where the checkbox column would disappear or shift position when pinning columns in the issues table.
* **Fixed Event Blade Data Display** - Resolved an issue where embedded issues in the emission event blade would not render data correctly after recent updates.
* **Fixed Emission Rate Calculations** - Corrected an issue where emission rate calculations were incorrect due to a unit conversion mismatch.
* **Fixed Attribution Equipment Display** - Resolved an issue where some equipment was not appearing in the attribution pane.
## Mobile App
### 🚀 Features
* **Improved Android Sync** - Replaced poll-based syncing with event-driven triggers and resolved conflicts between Event Hub sync and offline queue sync for more reliable data synchronization.
* **Faster Android Issue Details** - Improved loading speed on the issue detail screen for a smoother field experience.
* **Android Offline Sync Redesign** - Redesigned the Android offline sync mechanism to align with the iOS architecture, improving reliability and consistency across platforms.
# Mar 25, 2026
Source: https://docs.sensorup.com/releases/2026-03-25
This release delivers significant improvements to the emissions management workflow, including group-by capabilities for emission events, customizable rate units in notification emails, and a repair date column on the leak dashboard. Multiple AI suggestion issues were resolved, covering time zone handling, performance, and error recovery. The mobile apps received stability fixes for offline sync, form display, and image handling, along with new site summary functionality on iOS.
## Web Application
### 🚀 Features
* **Rate Unit Preferences in Emails** - Request notification emails now display emission rates in the unit format preferred by each user, ensuring consistent measurement reporting across the platform.
* **Group By for Emission Events** - Emission events can now be grouped by key attributes, making it easier to analyze and compare emissions data across different categories.
* **Persistent Column Settings** - Column visibility preferences on the Observations page are now preserved when switching between data sources, eliminating the need to reconfigure your view each time.
* **Repair Date on Leak Dashboard** - The leak dashboard now includes a dedicated repair date column, providing clearer visibility into leak remediation timelines.
* **Extended Observation Window** - The observation-to-event matching window has been extended from 90 to 180 days, reducing the chance of valid observations being excluded from emission event records.
* **Live Asset Updates** - Assets now update in real time using a more efficient data connection, reducing delays when viewing current asset status.
### 🐞 Bugs
* **Fixed AI Suggestion Time Zone** - AI suggestions now correctly respect the user's configured time zone preference, resolving an issue where suggestions were generated using incorrect time references.
* **Faster AI Suggestion Loading** - Resolved a performance regression that caused AI suggestion generation to take significantly longer than expected.
* **Fixed Emission Rate Display** - Corrected an issue where the emission rate average displayed as zero on the Emission Events page instead of showing the actual calculated value.
* **Fixed AI Suggestion Counts** - Year-to-date counts in AI suggestions are now calculated correctly, resolving a persistent miscounting issue.
* **AI Suggestion Error Recovery** - The AI suggestion button now properly recovers after a backend service error, instead of becoming unresponsive and requiring a page refresh.
* **Fixed Duplicate Query** - Resolved an issue where the Emission Events page was firing redundant data queries, improving page load performance.
* **Fixed Rate Column Export** - The rate column on the Emission Overview dashboard now exports correctly, resolving an issue where exported data was incomplete or missing.
## Mobile App
### 🚀 Features
* **Site Summary on iOS** - The iOS app now supports configurable site summary views, giving field operators quick access to key site information during inspections.
### 🐞 Bugs
* **Fixed Image Rotation on Android** - Portrait-oriented images selected from the gallery no longer rotate unexpectedly when submitted through the Android app.
* **Fixed Offline Sync Errors** - Resolved an issue on Android where a failed deletion during offline sync could incorrectly prevent other pending changes from being synchronized.
* **Fixed Multi-Select Display** - Dropdown fields converted to multi-select now display values correctly in mobile forms, resolving an issue where incorrect values were shown.
* **Fixed Android Fragment Crash** - Resolved a crash on Android that occurred when attempting to access view models from a detached fragment, improving app stability.
* **Fixed Duplicate Form Labels** - Location questions in mobile forms no longer display duplicate labels, cleaning up the form interface for field operators.
* **Fixed Subtask List Refresh** - The subtask list on Android now refreshes immediately after deleting an item, instead of requiring a manual refresh to see the updated list.
* **Fixed Android Publishing Error** - Resolved an intermittent error on Android that could occur during data publishing, improving the reliability of field data submissions.
# Apr 8, 2026
Source: https://docs.sensorup.com/releases/2026-04-08
This release focuses on reliability and field operator efficiency. Key additions include larger video upload support, inspection data export, and Emission Observation (EO) details in notification emails. Mobile users can now reassign issues directly from issue detail and benefit from persistent search in Site Summary. Several bugs affecting form uploads and the EO History tab have been resolved.
## Web Application
### 🚀 Features
* **Larger Video Uploads** - The maximum video file upload size has been increased beyond 30MB, allowing users to attach larger inspection recordings directly from the dashboard.
* **Emission Details in Notifications** - Issue notification emails now include Emission Observation (EO) details, giving recipients immediate context about related emissions without needing to open the platform.
* **Inspections Tab Export** - A new export button on the Inspections tab allows users to download inspection data for offline analysis and reporting.
* **Enhanced OGI Request Fields** - The description field in Optical Gas Imaging (OGI) inspection requests now supports longer text entries and is required, ensuring operators provide adequate context for each request.
### 🐞 Bugs
* **Fixed Form File Upload** - Resolved an issue where uploading images or videos in conditional form fields would reset the controlling field value, and where reopening a form displayed an incorrect image count.
* **Fixed EO History Tab Error** - Resolved a server error that prevented the Emission Observation (EO) History tab from loading, restoring access to historical emission event data.
## Mobile App
### 🚀 Features
* **Persistent Site Summary Search** - Search queries in the Site Summary now persist when switching between Leak and Vent tabs, eliminating the need to re-enter search terms.
* **Issue Reassignment on Mobile** - Field operators can now reassign issues directly from the issue detail screen in the mobile app, streamlining task handoffs without needing the web platform.
# Apr 28, 2026
Source: https://docs.sensorup.com/releases/2026-04-28
This release delivers significant performance improvements, emission management enhancements, and critical bug fixes. Highlights include Venting Flaring Blowdown (VFB) column configuration and severity display, and fresher dashboard data. Over a dozen bug fixes address server timeouts, data retrieval issues, email notification accuracy, and observation loading errors across both web and mobile platforms.
## Web Application
### 🚀 Features
* **VFB Column Configuration** - Venting Flaring Blowdown (VFB) fields are now available in the configurable columns for the Emission Management table, allowing operators to customize their view with VFB-specific data.
* **Fresher Dashboard Data** - Emission Observation (EO) and Emission Event (EE) dashboards now reflect more current data by merging current-month records during processing, reducing the delay between data ingestion and dashboard visibility.
* **VFB Severity Display** - The Venting Flaring Blowdown (VFB) modal now displays a severity field with a configurable default value, giving operators immediate visibility into emission severity when reviewing flyby results.
### 🐞 Bugs
* **Fixed Asset Hierarchy Error** - Resolved an error that occurred when querying asset hierarchy data, which could prevent Emission Event (EE) details from loading properly.
* **Repaired Orphaned Observations** - Identified and repaired observations that had become orphaned from their associated Emission Events, restoring proper data relationships.
* **Fixed EE Table Column Data** - Resolved an issue where asset ID and asset reference columns in the Emission Events (EE) table would be cleared when opening the detail blade.
* **Fixed Detection Data Retrieval** - Resolved an issue where detection records stored in the legacy database were silently dropped during retrieval, ensuring all detection data is now correctly returned.
* **Fixed Server Timeout Errors** - Resolved intermittent 502 errors that caused timeouts and application crashes, improving overall platform stability.
* **Fixed Stale Observation References** - Resolved an issue where observations continued to reference deleted Emission Events (EE), preventing errors when loading observation data.
* **Fixed AI Suggestion Rate Display** - Corrected a discrepancy where the AI-suggested emissions rate did not match the rate displayed in the emissions view.
* **Fixed Location Data in Emails** - Resolved an issue where Emission Observation (EO) latitude and longitude coordinates were not included in email notifications, restoring location context for recipients.
* **Fixed Email Task Links** - Corrected email notification links so that clicking 'View task' now navigates to the correct site.
* **Fixed Media URL Handling** - Resolved an issue with Emission Observation (EO) media file URL parsing where commas in filenames could cause incorrect file references.
* **Fixed Observation Loading Error** - Resolved an issue where users encountered an 'Unable to load observations' error when accessing observation data.
* **Fixed Emission Event Export** - Resolved an issue where Emission Event (EE) exports would not consolidate properly due to a configuration mismatch, ensuring complete export files are generated.
* **Fixed VFB Request Submission** - Resolved an inconsistency where submitting a Venting Flaring Blowdown (VFB) or Optical Gas Imaging (OGI) inspection request was blocked on the detail blade while remaining available through other actions.
## Mobile App
### 🚀 Features
* **Backend-Driven Issue Deletion** - Issue deletion in the mobile app now follows the backend-driven actions API, ensuring deletion behavior is consistent across platforms and respects server-side business rules.
### 🐞 Bugs
* **Fixed Site Check-in Dashboard** - Resolved an issue where the Site Check-in Dashboard displayed no data, restoring visibility into check-in activity.
# May 7, 2026
Source: https://docs.sensorup.com/releases/2026-05-07
This release includes VFB inspection form improvements, fixes for stale emission event status data, and mobile reliability improvements for field operations.
## Web Application
### 🚀 Features
* **Updated VFB Request Form** - The Venting Flaring Blowdown (VFB) request form now captures structured inspection fields, reducing manual data entry and ensuring requests contain the information needed for downstream processing.
### 🐞 Bugs
* **Fixed Stale Status on Closed Emission Events** - Resolved an issue where closed Emission Events displayed outdated status reasons and resolution explanations, showing misleading banners that referenced open-state conditions.
* **Fixed OGI Asset Attribution in Exports** - Resolved an issue where OGI observations that arrived as unattributed were missing asset references in data exports, even after attribution was completed on the Emission Event.
## Mobile App
### 🐞 Bugs
* **Fixed In-Progress Form Deletion** - Field inspectors can now delete in-progress forms in the mobile app, eliminating the need to contact support to clear incomplete work.
* **Fixed Unsubmitted Issue Deletion** - Users can now delete unsubmitted issues that were created via Emission Operations inspection requests in the mobile app, resolving an issue where these items appeared greyed out.
* **Fixed Error Message on App Launch** - Resolved an issue where users saw an AWS error message when opening the mobile app, which appeared across multiple environments on login.
# May 12, 2026
Source: https://docs.sensorup.com/releases/2026-05-12
This release delivers multi-observation inspection requests, significant Emission Events page performance improvements, and several reliability fixes across web and mobile. Operators can now attach multiple flyover observations to a single OGI request, and the Emission Events page loads large datasets without freezing the browser.
## Web Application
### 🚀 Features
* **Multi-Observation Inspection Requests** - When creating an OGI or field inspection request from an emission event, operators can now select multiple related observations to attach to a single request. This gives field technicians direct context about which detections triggered the inspection and links the resulting work back to specific observations.
* **Faster Emission Events Page** - The Emission Events by Site page now processes large datasets in a background thread, eliminating browser freezes when loading thousands of events over long date ranges.
* **Improved Loading Indicators** - The Emission Management page now displays accurate loading status messages during data retrieval and processing, replacing the previous blank table or misleading "no data" display.
* **Filtered Asset Dropdowns** - Deleted assets are no longer shown in the Add Task modal asset dropdown, preventing users from accidentally assigning tasks to decommissioned equipment.
* **Target Asset Picker Fix** - Resolved a tooltip display issue in the Target Asset picker where tooltips were cropped or hidden in asset hierarchies with only one or two levels.
### 🐞 Bugs
* **Fixed Photo Deletion in Issue Editor** - Resolved an issue where deleting photos from an existing issue without uploading new images would not persist the deletion, causing removed photos to reappear after saving.
* **Fixed Export Data Quality** - Resolved an issue where certain detection records with non-standard measurement types appeared in the Observations Dashboard export, causing unexpected rows in downloaded data files.
* **Fixed Air Monitor Response Form** - Resolved an error that prevented users from submitting Air Monitor Response forms when the target asset could not be loaded, blocking the form workflow entirely.
* **Fixed Observations Table Crash** - Resolved an issue where the Emission Event detail panel's observations table could crash when observation data contained duplicate contributing observation entries.
## Mobile App
### 🚀 Features
* **Source Attribution Details in Outpost** - Field technicians can now view Source Category, Attribution Explanation, and Emission Location Height directly within inspection tasks in Outpost, providing richer context for field work.
* **Backend-Driven Issue Deletion** - Issue deletion in the mobile app now follows the backend-driven actions API, ensuring deletion behavior is consistent across platforms and respects server-side business rules.
* **Fixed Android Startup Error** - Resolved an issue on Android where a background service initialization delay could cause the app to become unresponsive on first install or after an update.
# Jun 1, 2026
Source: https://docs.sensorup.com/releases/2026-06-01
This release introduces post-creation observation linking and unlinking on inspection tasks, deep linking for issues, larger video uploads, offline deletion validation on mobile, and several critical bug fixes across web and mobile platforms.
## Web Application
### 🚀 Features
* **Post-Creation Observation Linking** - Operators can now add or remove related observations from existing inspection tasks after creation. Previously, observations could only be attached at the time a request was created. The new link/unlink controls appear directly on the Issue Detail panel.
* **Deep Linking for Issues** - Issues now support direct URL links, allowing users to share or bookmark specific tasks and navigate directly to them from notifications, emails, or external tools.
* **Larger Video Uploads** - The maximum video file upload size has been increased to 100MB, allowing users to attach longer inspection recordings directly from the dashboard.
### 🐞 Bugs
* **Fixed Merge Functionality Hang** - Resolved an issue where the merge action on the Emission Events page would hang after the first use, requiring a full page refresh before merging again.
* **Fixed Observations Page Loading** - Resolved an error that prevented the Observations page from loading when certain SCADA query fields were unavailable.
* **Fixed Leak Dashboard Unit Mismatch** - Resolved an inconsistency where the Leaks dashboard displayed emission rates in a different unit than the Leak detail blade, even after updating the unit preference in Settings.
* **Fixed Related Observations Error** - Resolved an error that could appear on the Issue Detail panel when loading related observation data, replacing the error with a graceful fallback.
* **Fixed Observations Dashboard Blank State** - Resolved an issue where the Emission Observations dashboard would go blank after repeatedly opening and closing the detail blade.
## Mobile App
### 🚀 Features
* **Offline Deletion Validation** - Issue deletion on mobile now enforces the same permission rules as the server (role-based access, ownership checks) even when the device is offline, preventing sync conflicts when connectivity is restored.
* **Link and Unlink Observations on Mobile** - Field technicians can now add or remove related observations from inspection tasks directly in Outpost, matching the new desktop capability.
### 🐞 Bugs
* **Fixed Inspection Date on Closed Tasks** - Closed inspections in Outpost now display the date the work was completed, instead of showing no date.
* **Fixed Android Offline Sync** - Resolved an issue where closing multiple subtasks at once on Android could leave orphan subtasks that reverted to in-progress after syncing.
* **Fixed Offline Sync Status Revert** - Resolved an issue where work items closed in Outpost while offline would revert to "In Progress" in the Work Management dashboard after syncing.
* **Fixed Closed Leak Visibility** - Resolved an issue where leaks closed out in Outpost were not appearing in the Leaks dashboard or in Emission Events.
# Jun 16, 2026
Source: https://docs.sensorup.com/releases/2026-06-16
This release delivers file attachments for Emission Events and Observations, automatic event closure for verified OGI repairs, a unified filtering toolbar, improved PDF export image layout, and critical mobile stability fixes.
## Web Application
### 🚀 Features
* **File Attachments for Emission Events** - Users can now upload, view, and manage file attachments on both Emission Events and Emission Observations. Files can be linked to specific observations using a reference dropdown, unlinked back to the event level, previewed inline, and downloaded. Attached files are preserved when merging events.
* **Automatic Event Closure for Verified Repairs** - Emission events tied to Optical Gas Imaging (OGI) observations now automatically close when a leak repair is verified and an end date is confirmed. Previously, events with verified repairs remained in an "In Progress" state, requiring manual tracking and closure.
* **Unified Filtering Toolbar** - All filtering now happens from a single toolbar location. Quick filters appear as blue chips and advanced column-specific filters appear as purple chips, both visible in one unified filter bar. Filters apply consistently across List, Map, and Split views, and mixed filter combinations can be saved as named views.
* **Improved PDF Export Image Layout** - Leak report PDF exports now arrange multiple inspection images in a single row, eliminating the manual Adobe Acrobat editing previously required to move images from secondary pages onto the main page before sharing with operators.
### 🐞 Bugs
* **Fixed OGI Request After Re-Attribution** - Resolved an issue where requesting an OGI inspection after re-attributing an Emission Event to a different asset would show a "Form not configured" error. The request form was still matching against the original observation's asset instead of the re-attributed source, causing a mismatch between the form selection and the target asset picker.
* **Fixed Duplicate Observations After Merge** - Resolved an issue where correlating emission events could produce duplicate leak observations in the Emissions Management table, making it difficult to distinguish actual detections from duplicates.
* **Fixed Inverted Satellite Plume Overlays** - Resolved an issue where UNEP satellite plume GeoTIFF overlays were rendered upside-down on the map, causing plume imagery to appear in incorrect orientations relative to the actual emission source.
## Mobile App
### 🐞 Bugs
* **Fixed iOS Launch Crash Loop (Offline Queue)** - Resolved a critical issue where a corrupted offline sync queue entry caused the iOS app to crash immediately on every launch, locking field technicians out entirely. The app now quarantines unprocessable queue entries and continues syncing the rest, preserving unsubmitted inspection data without requiring a reinstall.
* **Fixed iOS Launch Crash Loop (Data Wipe)** - Resolved a separate critical issue where a synchronous database wipe during login blocked the main thread long enough for the iOS watchdog to kill the app, creating a persistent crash loop on devices with large local data stores. The wipe now runs asynchronously off the main thread.
* **Fixed iOS Crash on Downloading Resources** - Resolved a memory issue where the iOS app would crash on the Downloading Resources page after a system update, caused by excessive memory usage during the initial resource download that triggered the OS watchdog.
* **Fixed Mobile Leaks Not Syncing** - Resolved an issue where leaks visible on the desktop application were missing in the mobile app, caused by the asset sync watermark using the current timestamp instead of the server response timestamp, which could skip records during sync delays.
* **Fixed Android Tablet Back Button After Rotation** - Resolved an issue on Android tablets where rotating the device during an OGI inspection and then pressing the back button would repeatedly navigate back to the issue detail screen instead of the issue list.
# Introduction to SensorUp: Drive Emissions Reduction at Scale
Source: https://docs.sensorup.com/solutions/enterprise-solutions/integrated-emission-management-solution
Discover SensorUp, a configurable emissions management platform designed to integrate your data, streamline operations, ensure compliance, and accelerate your journey to significant emissions reduction.
# Introduction to SensorUp: A Configurable Emissions Management Platform
Welcome to SensorUp! We provide an enterprise-grade, **configurable emissions management platform** designed to help organizations like yours tackle the most pressing emissions challenges and **drive significant reduction at scale**. Our platform integrates your diverse data sources, streamlines complex workflows, and provides the actionable insights needed to achieve your sustainability and operational excellence goals.
> [!NOTE]
>
> SensorUp empowers you to move beyond siloed data and manual processes,
> offering a unified, adaptable solution that accelerates your emissions
> reduction journey.
## The Challenge: Managing Emissions in a Complex Landscape
Effectively managing and reducing emissions presents numerous hurdles:
* **Data Overload & Silos:** Data from sensors, inspections, operational systems, and third-party feeds is often voluminous, disparate, and difficult to consolidate for a holistic view.
* **Evolving Regulations & Market Demands:** Keeping pace with complex, changing compliance requirements (GHGRP, OGMP 2.0, Veritas) and voluntary market standards is a constant effort.
* **Operationalizing Insights:** Translating raw data into actionable steps for field teams, operational adjustments, and strategic decisions can be slow and inefficient.
* **Scaling Reduction Efforts:** Moving from pilot projects to enterprise-wide emissions reduction requires robust, scalable systems and processes.
* **The "Build vs. Buy" Dilemma:** Developing a comprehensive, in-house emissions management solution is a massive undertaking, requiring significant time, specialized expertise, ongoing maintenance, and can divert focus from core business activities.
## The SensorUp Solution: Configuration & Integration at Scale
SensorUp addresses these challenges by providing a **configurable platform**, not a rigid, one-size-fits-all product. We understand that each organization has unique assets, operational workflows, and reporting needs. Our approach combines the power of a specialized, off-the-shelf platform with the flexibility to adapt to your specific environment.
**Key Pillars of Our Approach:**
1. **Unified Data Foundation (Connected Assets):** We start by helping you integrate and contextualize all your asset-related data, creating a single source of truth. (See [Introduction to Connected Assets](/overview/intro-connected-assets))
2. **Streamlined Action & Workflow (Connected Operations):** We connect emission insights directly to field service actions and operational responses, automating and optimizing your workflows. (See [Introduction to Connected Operations](/overview/intro-connected-operations))
3. **Assured Compliance & Market Readiness (Connected Markets):** We provide the tools for robust reconciliation, accurate reporting, and confident participation in regulatory and voluntary markets. (See [Introduction to Connected Markets](/overview/intro-connected-markets))
By integrating these pillars, SensorUp enables a continuous cycle of measurement, analysis, action, and reporting, all geared towards scalable emissions reduction.
## Why Choose a Configurable Platform like SensorUp?
When considering how to tackle emissions management, the "build vs. buy" question is critical. Building a custom solution from scratch is resource-intensive and carries significant risk. SensorUp offers the advantages of a specialized platform while providing the configurability you need:
> [accordion] Accelerate Time-to-Impact & Reduction
>
> Leverage a feature-rich platform built on years of emissions management
> expertise. Instead of spending 12-24+ months building a foundational system,
> you can start configuring SensorUp to your needs and seeing results much
> faster, accelerating your progress towards reduction targets.
> [accordion] Focus on Your Core Mission, Not Software Development
>
> Your expertise lies in your core operations, not in building and maintaining
> complex enterprise software for emissions. SensorUp handles the underlying
> platform architecture, data models, security, scalability, and ongoing
> evolution, allowing your teams to focus on what they do best: reducing
> emissions and optimizing operations.
> [accordion] Benefit from Deep Domain Expertise & Best Practices
>
> SensorUp is built with deep knowledge of emissions sources, regulatory
> frameworks (OGMP 2.0, GHGRP, Veritas), data standards (ISO 19156:2023), and
> industry best practices. This expertise is embedded in our platform, saving
> you the effort of acquiring and maintaining it internally.
> [accordion] Achieve True Scalability & Future-Proofing
>
> Our platform is designed to scale with your needs, from managing a few
> assets to tens of thousands, and handling increasing data volumes from
> diverse sources. We continuously update SensorUp to incorporate new
> technologies, integrate with emerging data providers, and adapt to evolving
> regulatory landscapes, future-proofing your investment.
> [accordion] Harness the Power of Configuration, Not Custom Code
>
> "Configurable" means you can tailor SensorUp to your specific asset
> hierarchies, data source schemas, business rules, workflows, and reporting
> formats primarily through setup and configuration UIs, low-code tools, and
> well-defined APIs—without extensive custom software development for every
> need. This provides flexibility while retaining the benefits of a
> standardized, supported platform.
> [accordion] Comprehensive Integration Capabilities
>
> A major challenge in any emissions program is integrating data. SensorUp is
> designed for this, offering multiple pathways – from low-code connectors to
> direct data feeds (S3, SFTP) and managed integrations – to connect your
> existing systems and new data sources efficiently. (See [Getting Started
> with Integrations](/use-sensorup/user-management/getting-started-integrations))
## Core Platform Modules at a Glance
SensorUp's configurable power is delivered through its integrated modules:
> [card] [Connected Assets](/overview/intro-connected-assets)
>
> Unify, standardize, and visualize all your asset and emissions data. Build a
> comprehensive asset registry as the foundation for accurate tracking and
> analysis.
> [card] [Connected Operations](/overview/intro-connected-operations)
>
> Streamline workflows from methane detection to field verification and
> repair. Automate actions and connect office insights with field activities
> seamlessly.
> [card] [Connected Markets](/overview/intro-connected-markets)
>
> Manage compliance with OGMP 2.0, GHGRP, Veritas, and other programs. Perform
> robust data reconciliation and generate accurate reports for all
> stakeholders.
## Who Benefits from SensorUp?
Our platform is designed to support various roles within your organization:
* **Operators & Field Teams:** Streamlined workflows, mobile tools, and clear actions.
* **Air Quality, ESG & Environmental Managers:** Comprehensive data, robust reporting, and tools for compliance and reduction strategy.
* **IT & Systems Integrators:** Flexible integration options, standardized data models, and a scalable architecture.
* **Leadership & Strategy Teams:** Actionable insights for data-driven decisions and progress tracking towards sustainability goals.
## Navigating This Documentation
These documents are designed to help you understand and effectively use the SensorUp platform:
* **Introductions:** High-level overviews of SensorUp and its core modules.
* **Getting Started Guides:** Practical steps for initial setup, data integration, and key workflows.
* **Feature Guides:** In-depth explanations of specific functionalities within each module.
* **API Reference:** Technical details for developers using our GraphQL API.
We are excited to partner with you on your emissions reduction journey!
## Next Steps
> [card] Platform Overview Deck
>
> Get a visual summary of SensorUp's capabilities and value proposition.
> (Coming soon)
> [card] Understanding Your Data: Datastreams
>
> Learn how SensorUp ingests and manages time-series data, a core component of
> all modules. (Coming soon)
> [card] Key Concepts & Terminology
>
> Familiarize yourself with common terms used throughout SensorUp and this
> documentation. (Coming soon)
> [card] [Request a Personalized Demo](https://sensorup.com/request-a-demo)
>
> See SensorUp in action and discuss your specific needs with our experts.
# Connected Operations
Source: https://docs.sensorup.com/solutions/enterprise-solutions/solutions-for-complex-operations
Comprehensive solutions designed to handle complex operational challenges with advanced monitoring, analysis, and management capabilities.
# Solutions for Complex Operations
*This page is currently under development. Content will be added soon.*
## Overview
Complex operations require sophisticated tools and processes to manage multiple variables, ensure safety, and maintain efficiency across diverse operational environments.
## Key Features
*Coming soon...*
## Getting Started
*Coming soon...*
## Use Cases
*Coming soon...*
## Next Steps
*Coming soon...*
# Simplifying OGMP
Source: https://docs.sensorup.com/solutions/enterprise-solutions/solutions-for-simplifying-ogmp
Streamlined solutions to simplify Oil and Gas Methane Partnership (OGMP) compliance and reporting processes.
# Solutions for Simplifying OGMP
*This page is currently under development. Content will be added soon.*
## Overview
Simplify your Oil and Gas Methane Partnership (OGMP) compliance with integrated tools and automated processes that reduce complexity and improve accuracy.
## Key Features
*Coming soon...*
## Getting Started
*Coming soon...*
## Use Cases
*Coming soon...*
## Next Steps
*Coming soon...*
# Streamline LDAR Operations
Source: https://docs.sensorup.com/solutions/enterprise-solutions/solutions-to-streamline-ldar
Comprehensive solutions designed to streamline Leak Detection and Repair (LDAR) processes with connected asset management, advanced emission analytics, intelligent event contextualization, and mobile field service management for maximum efficiency and regulatory compliance.
# Streamline LDAR Operations: Smart Detection, Field Management & Compliance
**Leak Detection and Repair (LDAR) operations face significant challenges in managing complex asset portfolios, integrating multiple detection technologies, coordinating field teams, and extracting actionable insights from emission data.** Traditional approaches often result in fragmented data, inefficient field operations, limited visibility into operational context, and missed opportunities for strategic emission reduction.
**Our integrated LDAR solution combines comprehensive asset management, advanced emission analytics, intelligent event contextualization, and mobile field service management.** This powerful combination provides unified visibility across your entire LDAR operation, enabling strategic decision-making, optimized field operations, improved compliance, and enhanced emission management.

> [card] [Connected Assets Platform](#connected-assets-platform)
>
> **The Problem:** LDAR operations require comprehensive asset management, emission detection integration, and data connectivity across multiple systems and sources.
> **The Solution:** Unified platform for managing assets, integrating emission detection technologies, and connecting with enterprise systems for seamless LDAR operations.
> [card] [Emission Insights & Analytics](#emission-insights-analytics)
>
> **The Problem:** Organizations need actionable insights from emission data to prioritize repairs, understand site performance, and make informed operational decisions.
> **The Solution:** Advanced analytics platform with asset and site dashboards, operational datastream integration, and comprehensive emission insights for strategic LDAR management.
> [card] [Event Contextualization](#event-contextualization)
>
> **The Problem:** Emission events need operational context to understand root causes, prioritize responses, and ensure accurate reporting and compliance.
> **The Solution:** Intelligent contextualization system that enriches emission data with operational context, enabling better decision-making and faster response times.
> [card] [Field Service Management](#field-service-management)
>
> **The Problem:** Field teams conducting LDAR operations need mobile tools, efficient task management, and streamlined workflows to maximize productivity and ensure compliance.
> **The Solution:** Comprehensive mobile field service platform with GPS-enabled task management, real-time work coordination, and optimized field efficiency tools for LDAR operations.
## Connected Assets Platform
**Challenge:** LDAR operations require comprehensive asset management, seamless integration with multiple emission detection technologies, and robust data connectivity across enterprise systems. Without a unified platform, organizations struggle with fragmented data, manual integration processes, and limited visibility into asset performance and emission sources.
**Our Solution:** Our connected assets platform provides **unified asset management, comprehensive emission detection integration, and enterprise-grade data connectivity** that centralizes all LDAR operations in a single, powerful system.
> [accordion] Asset Management: Comprehensive Asset Control
>
> **GraphQL-powered asset management system for sites, pipelines, wells, equipment, and components with flexible schema management.**
>
> * **Flexible Asset Modeling:** Manage complex asset hierarchies with custom properties and extensions
> * **API-Driven Management:** GraphQL APIs for programmatic asset control and integration
> * **Scalable Architecture:** Support for large-scale industrial operations with thousands of assets
> [accordion] Emission Detection Integration: Multi-Source Connectivity
>
> **The Problem:** LDAR operations require integration with multiple detection technologies and data sources, often resulting in fragmented data and manual processes.
>
> **Our Solution:** Comprehensive integration platform supporting multiple emission detection technologies including InsightM, Qube, CarbonMapper, SaiGeo, and Kuva for unified data management.
>
> > [!NOTE]
> >
> > **Success Story:** A major midstream operator integrated 5 different detection technologies, reducing data integration time by 80% and improving detection accuracy by 60%.
>
> *Supports REST APIs and real-time data streaming*
> [accordion] Datastream Integration: Enterprise Connectivity
>
> **The Problem:** LDAR data must integrate seamlessly with existing enterprise systems and cloud environments for comprehensive operational visibility.
>
> **Our Solution:** Powerful GraphQL query API with SQL support, low-code integration capabilities, and cloud connectivity for AWS, Azure, and FTP environments.
>
> *Compatible with major enterprise systems and cloud platforms*
> [accordion] Advanced Security & Identity: Enterprise-Grade Protection
>
> **The Problem:** Industrial LDAR operations require enterprise-grade security, identity management, and compliance with strict security requirements.
>
> **Our Solution:** Advanced security features including SIEM integration, SSO and federated identity support, and comprehensive audit logging for enterprise compliance.
## Emission Insights & Analytics
**Challenge:** Organizations need actionable insights from emission data to prioritize repairs, understand site performance, and make informed operational decisions. Without proper analytics, LDAR operations lack strategic direction, leading to inefficient resource allocation and missed opportunities for emission reduction.
**Our Solution:** Our advanced analytics platform provides **comprehensive emission insights, operational datastream integration, and strategic dashboards** that transform raw data into actionable intelligence for optimized LDAR operations.
> [accordion] Asset Dashboard: Priority Asset Management
>
> **Comprehensive dashboard for understanding priority assets for repair and abatement work with complete asset overview capabilities.**
>
> * **Priority Asset Identification:** Automated ranking of assets based on emission frequency and severity
> * **Repair Planning:** Visual tools for planning and tracking repair activities across asset portfolios
> * **Performance Monitoring:** Real-time tracking of asset performance and emission trends
> [accordion] Site Dashboard: Detailed Site Analysis
>
> **The Problem:** Site-level emission analysis is critical for understanding local performance and identifying improvement opportunities.
>
> **Our Solution:** Detailed site dashboard providing comprehensive emission analysis, source identification, and performance metrics for individual facilities.
>
> > [!NOTE]
> >
> > **Success Story:** A refinery operator used site dashboards to identify 40% more emission sources and reduced site-level emissions by 35% within six months.
>
> *Supports multiple sites with comparative analysis capabilities*
> [accordion] Operational Datastreams: Contextual Data Integration
>
> **The Problem:** LDAR insights require integration with operational data to understand the full context of emission events and operational conditions.
>
> **Our Solution:** Comprehensive operational datastream integration supporting combustion test data, work orders, maintenance records, venting & flaring notifications, production data, and SCADA systems.
>
> *Supports custom operational datastreams for specialized requirements*
> [accordion] Workflow Actions: Integrated Response Management
>
> **The Problem:** Emission insights must translate into actionable workflows that connect teams and drive response activities.
>
> **Our Solution:** Integrated action system that enables teams to take immediate action within emission events and insights, connecting analysis with operational response.
## Event Contextualization
**Challenge:** Emission events require operational context to understand root causes, prioritize responses, and ensure accurate reporting and compliance. Without proper contextualization, organizations struggle to understand why emissions occur, leading to ineffective responses and missed opportunities for prevention.
**Our Solution:** Our intelligent contextualization system provides **operational context enrichment, comprehensive data integration, and automated workflow procedures** that transform emission events into actionable intelligence with full operational understanding.
> [accordion] Event Contextualization: Operational Data Enrichment
>
> **Advanced system for enriching emission data with operational context from your operational datastreams for comprehensive event understanding.**
>
> * **Operational Context Integration:** Automatically correlate emission events with operational conditions and activities
> * **Root Cause Analysis:** Identify operational factors contributing to emission events
> * **Predictive Insights:** Use operational patterns to predict and prevent future emission events
> [accordion] Standardized Procedures: Automated LDAR Workflows
>
> **The Problem:** LDAR operations require standardized procedures that can be executed consistently across teams and locations with proper documentation and tracking.
>
> **Our Solution:** Comprehensive procedure system enabling team members to perform unique procedures containing multiple coordinated tasks including Ops Comments, Super Emitter Response, and Drone Dispatch.
>
> > [!NOTE]
> >
> > **Success Story:** An oil & gas operator standardized LDAR procedures across 15 sites, reducing procedure execution time by 50% and improving compliance documentation by 90%.
>
> *Supports custom procedure creation and enterprise workflow integration*
> [accordion] Enterprise Integration: Seamless System Connectivity
>
> **The Problem:** LDAR contextualization requires integration with existing enterprise systems for comprehensive operational understanding and workflow coordination.
>
> **Our Solution:** Built-in integrations with major enterprise systems including SAP and TrueContext for seamless data flow and hybrid work management processes.
>
> *Supports REST API and webhook integrations for custom enterprise systems*
> [accordion] Operations Dashboard: Real-Time Context Visibility
>
> **The Problem:** Management needs real-time visibility into LDAR operation status, contextual information, and procedure progress across multiple sites and teams.
>
> **Our Solution:** Re-usable operations dashboard component that displays the state of all procedures, contextual data, and workflows in real-time with customizable views and reporting.
>
> *Available as web-based dashboard with mobile-responsive design*
## Field Service Management
**Challenge:** Field teams conducting LDAR operations face significant challenges in task coordination, mobile data collection, and workflow efficiency. Without proper mobile tools and field management systems, technicians struggle with inefficient task routing, manual data entry, and lack of real-time coordination, leading to delayed repairs and compliance gaps.
**Our Solution:** Our comprehensive field service management platform provides **mobile-optimized tools, GPS-enabled task management, and streamlined field workflows** that maximize technician productivity and ensure consistent, compliant LDAR operations.
> [accordion] Mobile Field Operations: GPS-Enabled Task Management
>
> **Advanced mobile platform with GPS-enabled map view for efficient task management and field coordination.**
>
> * **Visual Task Planning:** Interactive map showing all work items with GPS coordinates for optimal route planning
> * **Real-Time Location Tracking:** GPS-enabled location tracking for technician safety and work progress monitoring
> * **Nearby Task Completion:** Automatic identification and prioritization of nearby tasks for maximum efficiency
> [accordion] Personalized Work Assignment: Individual Task Management
>
> **The Problem:** Field technicians often struggle to understand their specific assignments, priorities, and deadlines, leading to confusion and missed tasks.
>
> **Our Solution:** Personalized work assignment interface that clearly displays each technician's specific tasks, priorities, and deadlines with real-time updates.
>
> > [!NOTE]
> >
> > **Success Story:** A major oil & gas operator reduced field technician confusion by 75% and improved task completion rates by 40% within the first month of implementation.
>
> *Requires mobile device with GPS capabilities*
> [accordion] Efficient Data Collection: Mobile-Optimized Forms
>
> **The Problem:** Manual data collection during LDAR inspections is time-consuming, error-prone, and difficult to standardize across teams.
>
> **Our Solution:** Mobile-optimized data collection tools with standardized forms, automated validation, and real-time data synchronization for consistent, accurate field data capture.
>
> *Compatible with iOS and Android devices with offline capabilities*
> [accordion] Field Efficiency Optimization: Mobile Performance
>
> **The Problem:** Field technicians need tools optimized for mobile use in challenging industrial environments with limited connectivity and harsh conditions.
>
> **Our Solution:** Mobile-first design with offline capabilities, rapid data input, and optimized performance for field conditions including low connectivity and extreme weather.
> [accordion] GPS Metadata Collection: Enhanced Context
>
> **The Problem:** LDAR operations require precise location data and contextual information for accurate reporting and compliance documentation.
>
> **Our Solution:** GPS-enabled data collection that automatically captures location metadata, timestamps, and environmental context for comprehensive LDAR documentation.
> [accordion] Standardized Field Procedures: Workflow Automation
>
> **The Problem:** LDAR field operations require standardized procedures that can be executed consistently across different teams and locations.
>
> **Our Solution:** Comprehensive procedure system enabling field teams to perform standardized LDAR procedures including Ops Comments, Super Emitter Response, and Drone Dispatch with real-time tracking and documentation.
>
> *Supports custom procedure creation and enterprise workflow integration*
> [accordion] Operations Dashboard: Real-Time Field Visibility
>
> **The Problem:** Management needs real-time visibility into field operation status, technician locations, and procedure progress across multiple sites and teams.
>
> **Our Solution:** Re-usable operations dashboard component that displays the state of all field procedures, technician locations, and work progress in real-time with customizable views and reporting.
>
> *Available as web-based dashboard with mobile-responsive design*
## Platform Foundation
**Our LDAR solutions are built on a robust, enterprise-grade platform that provides the security, scalability, and integration capabilities required for industrial operations.**
> [accordion] User Management: Secure Access Control
>
> **Comprehensive user management system with role-based access control, secure authentication, and audit logging for enterprise security requirements.**
> [accordion] Integration Support: Seamless Implementation
>
> **Dedicated integration support services including standard and premium options with forward-deployed engineering support for rapid implementation and customization.**
> [accordion] Tiered Support: Enterprise-Grade Service
>
> **Comprehensive support services with standard and premium tiers, including high availability support with on-call capabilities outside standard business hours for critical LDAR operations.**
# Consultants Solutions
Source: https://docs.sensorup.com/solutions/partner-solutions/solutions-for-consultants
Specialized solutions for consultants to deliver expert services, manage client projects, and provide valuable insights.
# Solutions for Consultants
*This page is currently under development. Content will be added soon.*
## Overview
Consultants require flexible tools and platforms to manage multiple client engagements, deliver expert analysis, and provide actionable recommendations.
## Key Features
*Coming soon...*
## Getting Started
*Coming soon...*
## Use Cases
*Coming soon...*
## Next Steps
*Coming soon...*
# Data Providers Solutions
Source: https://docs.sensorup.com/solutions/partner-solutions/solutions-for-data-providers
Complete platform solution for data providers to manage connected assets, emission monitoring, and deliver value-added services to their clients with enterprise-grade support.
# Solutions for Data Providers
**Data providers face increasing pressure to deliver comprehensive, real-time insights while managing complex asset networks and emission monitoring requirements.** Traditional data collection and reporting methods often lack the integration, scalability, and analytical depth that modern industrial operations demand.
**Our Solutions for Data Providers suite transforms how you manage connected assets and emission data, enabling you to deliver superior value to your clients through integrated asset management, advanced emission monitoring, and enterprise-grade platform capabilities.**
> [card] [Connected Assets Management](#connected-assets-management)
>
> **The Problem:** Managing diverse asset types, hierarchies, and emission data streams across multiple client sites creates operational complexity and data silos.
> **The Solution:** Unified platform for comprehensive asset management with real-time emission monitoring, correlation, and event management capabilities.
> [card] [Enterprise Platform](#enterprise-platform)
>
> **The Problem:** Scaling data services requires robust user management, security, and access controls that traditional systems can't provide.
> **The Solution:** Enterprise-grade platform with advanced user management, role-based access, and secure multi-tenant architecture.
> [card] [Professional Services](#professional-services)
>
> **The Problem:** Complex integrations and ongoing support requirements demand specialized expertise and dedicated resources.
> **The Solution:** Comprehensive integration support and tiered support services to ensure successful deployment and ongoing operational excellence.
## Connected Assets Management
**Challenge:** Data providers must manage complex asset networks across multiple client sites while collecting, processing, and analyzing emission data streams. Traditional approaches create data silos, lack real-time insights, and make it difficult to provide comprehensive value to clients.
**Our Solution:** **Integrated asset and emission management platform** that unifies data collection, processing, and analysis across all connected assets, enabling you to deliver actionable insights and comprehensive reporting to your clients.
> [accordion] Asset Management: Comprehensive Infrastructure Control
>
> Complete asset lifecycle management for sites, pipelines, wells, equipment, and components with flexible data access and management capabilities.
>
> * **Multi-Asset Support:** Manage diverse asset types including sites, pipelines, wells, equipment, and components through GraphQL APIs
> * **Hierarchical Management:** Organize assets in logical hierarchies with API-driven parent-child relationships
> * **Custom Properties:** Extend asset schemas with custom properties and metadata to meet specific client requirements
> * **Flexible Integration:** Access data through GraphQL APIs or low-code interfaces for maximum flexibility
> [accordion] Emission Datastreams: Real-Time Data Collection
>
> **The Problem:** Collecting and processing emission data from multiple sources requires robust infrastructure and standardized data formats.
>
> **Our Solution:** Standardized emission and observation datastreams using EmisionML format, ensuring consistent data quality and enabling advanced analytics.
>
> > [!NOTE]
> >
> > **Success Story:** A leading data provider reduced data processing time by 60% and improved client reporting accuracy by 40% using standardized emission datastreams.
> [accordion] Emission Operations: Advanced Event Management
>
> **The Problem:** Raw emission data requires sophisticated processing to identify, correlate, and manage emission events effectively.
>
> **Our Solution:** Complete emission event lifecycle management with advanced correlation, time estimation, and source attribution capabilities.
>
> * **Event Detection:** Map, table, and summary views of all emission detections across assets
> * **Source Attribution:** Designate physical sources and source categories for accurate reconciliation
> * **Intelligent Correlation:** Automatically correlate observations into meaningful emission events
> * **Time & Rate Engine:** Determine precise event timing and emission rates from correlated observations
> * **Event Resolution:** Comprehensive event management including resolution, false alarm handling, and detailed reporting
## Enterprise Platform
**Challenge:** Scaling data services across multiple clients requires enterprise-grade security, user management, and access controls that traditional systems cannot provide.
**Our Solution:** **Robust enterprise platform** with advanced user management, role-based access controls, and secure multi-tenant architecture designed for data providers serving multiple clients.
> [accordion] User Management: Secure Access Control
>
> Comprehensive user management system with secure access methods and role-based permissions for multi-client environments.
>
> * **Multi-User Support:** Manage users across multiple client organizations with centralized administration
> * **Secure Authentication:** Multiple secure access methods including SSO and multi-factor authentication
> * **Role-Based Access:** Granular permission controls to ensure data security and client confidentiality
> * **Audit Trail:** Complete user activity tracking for compliance and security monitoring
> [accordion] Groups & Roles: Flexible Data Access
>
> **The Problem:** Different clients and teams need varying levels of data access while maintaining security and confidentiality.
>
> **Our Solution:** Flexible group and role management system that allows you to subdivide data access within teams and across client organizations.
>
> > [!NOTE]
> >
> > **Success Story:** A data provider serving 15+ clients implemented role-based access, reducing security incidents by 90% while improving client satisfaction through tailored data access.
## Professional Services
**Challenge:** Complex integrations and ongoing operational support require specialized expertise and dedicated resources that many data providers lack internally.
**Our Solution:** **Comprehensive professional services** including integration support and tiered support options to ensure successful deployment and ongoing operational excellence.
> [accordion] Integration Support: Seamless Implementation
>
> Expert integration support to ensure smooth deployment and optimal system performance from day one.
>
> * **Standard Support:** Customer and partner-driven integration with forward-deployed support for guidance and troubleshooting
> * **Premium Support:** Forward-deployed engineer-driven integration with full hands-on support for complex implementations
> * **Best Practices:** Proven integration methodologies and best practices for optimal system performance
> * **Custom Solutions:** Tailored integration approaches for unique client requirements and existing infrastructure
> [accordion] Tiered Support: Ongoing Excellence
>
> **The Problem:** Ongoing system support and maintenance require specialized knowledge and rapid response capabilities.
>
> **Our Solution:** Comprehensive support tiers designed to meet different operational requirements and service level expectations.
>
> * **Standard Support:** Tier 1 and Tier 2 support during standard MST business hours with expert technical assistance
> * **Premium Support:** High-availability support with on-call capabilities outside standard business hours for critical operations
> * **Rapid Response:** Dedicated support channels for urgent issues and system optimization
> * **Proactive Monitoring:** Continuous system monitoring and proactive issue resolution
## Platform Foundation
**Enterprise-grade platform infrastructure** that provides the reliability, security, and scalability needed to deliver exceptional data services to your clients.
> [accordion] Scalable Architecture: Built for Growth
>
> Cloud-native platform architecture designed to scale with your business and client growth, ensuring consistent performance and reliability.
> [accordion] Security & Compliance: Enterprise-Grade Protection
>
> Comprehensive security framework with encryption, access controls, and compliance features to protect your data and meet regulatory requirements.
# Field Service Partners
Source: https://docs.sensorup.com/solutions/partner-solutions/solutions-for-field-service-management-companies
Streamlined field service management solution combining asset management, field operations, and automated workflows to optimize service delivery and client satisfaction.
# Solutions for Field Service Management Partners

Field service companies struggle with **disconnected workflows, data silos, and inefficient field operations** that impact service delivery and profitability. They need to manage multiple client assets, coordinate field teams, and deliver accurate reports while maintaining compliance with regulations and their clients' corporate mandates.
Our solution provides a unified platform that **streamlines field operations, enhances data accuracy, and enables seamless client reporting**—empowering field service companies to deliver superior service quality with quick data handoffs and transparency while reducing costs and improving productivity.
> [card] [Connected Assets](#connected-assets)
>
> **The Problem:** Scattered asset data and inconsistent client information across multiple sites. \
> **The Solution:** Centralized asset management providing a single platform for efficient work planning.
> [card] [Connected Operations](#connected-operations)
>
> **The Problem:** Inefficient tools and manual processes that slow service delivery. \
> **The Solution:** Optimized field operations with automated workflows, mobile applications and real-time coordination.
> [card] [Connected Platform](#connected-platform)
>
> **The Problem:** Need enterprise security and segregated user management for multiple clients. \
> **The Solution:** Robust platform with comprehensive security controls and tiered support options.
## Connected Assets
**Challenge:** Managing diverse asset types across multiple client sites leads to disconnected information, poor work planning, and difficulty demonstrating value to clients.
**Our Solution:** Centralized asset management capabilities that integrate client data, prioritized work planning, and deliver accurate client reporting for **professional, data-driven field service management**.
> [accordion] Asset Management: Centralized Asset Information
>
> Core asset management tools to maintain comprehensive, up-to-date asset information for all clients, set-up or maintained by the client or via SensorUp engineers.
>
> * **Manage Assets:** GraphQL (optionally via low-code) management of sites, pipelines, wells, equipment, components and more across all client locations
> * **Manage Asset Hierarchy (API):** GraphQL API to change asset parent references for flexible organization
> * **Manage Asset Schema Properties (API):** GraphQL to manage Asset schema with extensions and custom properties for different client needs
> [accordion] Emission Datastreams: Advanced Integration Capabilities
>
> **The Problem:** Integrating multiple detection data sources is complex and time-consuming.
>
> **Our Solution:** Built-in integration with leading detection technologies enables integrated monitoring services without complexity.
>
> > [!NOTE]
> >
> > **Success Story:** A field service partner reduced client onboarding time by 60% using pre-integrated detection technologies.
>
> **Key Capabilities:**
>
> * **Emission / Observation Datastreams:** Standardized emission events and observations
## Connected Operations
**Challenge:** Outdated tools, manual processes, and disconnected systems slow service delivery, reduce data accuracy, and create coordination problems between office and field teams.
**Our Solution:** Optimized mobile application tools and streamlined workflows that **transform field service delivery** by reducing manual work, improving data quality, and accelerating service completion.
> [accordion] Outpost App: Mobile Field Operations
>
> Mobile app providing field teams with efficient tools while maintaining data accuracy and office connectivity.
>
> * **My Issues:** See work items assigned to each field user for clear task visibility
> * **Field Efficiency:** Optimization for quick data input, reducing administrative time
> * **GPS Inputs:** Collect data with GPS metadata for improved location accuracy
> [accordion] Connected Workflows: Streamlined Operations
>
> **The Problem:** Manual coordination, inconsistent procedures, and lack of operational visibility lead to inefficiencies.
>
> **Our Solution:** Automated workflows ensure consistent service delivery with real-time visibility.
>
> > [!NOTE]
> >
> > **Success Story:** A field service partner improved completion rates by 40% and reduced client complaints by 25% through standardized workflows.
>
> **Key Capabilities:**
>
> * **Operations Dashboard:** Real-time visibility into service process and customer delivery
## Connected Platform
**Challenge:** Field service companies need enterprise-grade security, user management, and support capabilities to serve multiple clients while maintaining data integrity and compliance.
**Our Solution:** Robust platform foundation that **enables scalable growth** while maintaining the highest standards of data security and service delivery.
> [accordion] Groups & Roles: Secure Multi-Client Management
>
> **The Problem:** Managing user permissions across different client accounts is complex and error-prone.
>
> **Our Solution:** Comprehensive groups and roles management maintains strict data separation between clients while providing appropriate access levels.
>
> **Key Capabilities:**
>
> * **Groups & Roles:** Define groups and roles to subdivide data access, ensuring proper data segregation and access control
> [accordion] Connected Services: Comprehensive Support
>
> **The Problem:** Finding the right level of support for successful implementation and ongoing operations can be challenging.
>
> **Our Solution:** Tiered support options provide the right level of assistance, from self-serve to premium support with dedicated resources.
>
> **Integration Support Options:**
>
> * **Standard:** Customer/partner driven with Forward Deployed Support
> * **Premium:** Full support from Forward Deployed Engineer
>
> **Ongoing Support Options:**
>
> * **Standard:** SensorUp provides Tier 1 and Tier 2 support during standard MST business hours
> * **Premium:** SensorUp provides high availability Tier 1 and Tier 2 support with on-call outside standard business hours
# SensorUp Modules (SKU's)
Source: https://docs.sensorup.com/solutions/solution-overview
Discover how SensorUp's solutions solve critical challenges in emissions management, from centralizing disparate data and prioritizing operational response to ensuring confident compliance in complex markets.
# SensorUp Platform: Solutions to Drive Emissions Reduction at Scale
In today's complex operational and regulatory landscape, managing emissions effectively means moving beyond spreadsheets and siloed systems. It requires a unified platform that can turn an overwhelming volume of data into clear, actionable insights that drive measurable reduction by **enabling better team collaboration and smarter facility management**.
SensorUp provides a configurable suite of solutions—**Connected Assets**, **Connected Operations**, and **Connected Markets**—designed to solve the specific challenges faced by operations managers, air quality specialists, and ESG leaders. This guide outlines the capabilities within each solution, framed around the problems they solve and the value they deliver.
> [card] [Connected Assets](#connected-assets)
>
> **The Problem:** Your data is scattered, accountability is leaking, and
> critical emission events get missed. **The Solution:** A foundational data
> hub that centralizes all your asset and emissions data into a single source
> of truth for real-time insights.
> [card] [Connected Operations](#connected-operations)
>
> **The Problem:** There's a critical gap between detecting an emission and
> taking effective action in the field. **The Solution:** An action-oriented
> engine that streamlines workflows, automates tasks, and empowers your field
> teams to act smarter and faster.
> [card] [Connected Markets](#connected-markets)
>
> **The Problem:** Emissions accounting, reconciliation, and reporting for
> standards like OGMP 2.0 is complex, uncertain, and audit-prone. **The
> Solution:** A comprehensive accounting and reporting suite for confident
> compliance and market participation.
## Connected Assets
**Challenge:** Your air quality specialists and operations managers are trapped in a reactive loop. Data from diverse sensors, aerial surveys, and operational systems is siloed in PDFs and separate logins, causing a "leakage of accountability." This manifests as missed emission events, unnecessary and costly field dispatches based on incomplete information, and an inability to trust your data for confident decision-making.
**Our Solution:** Connected Assets is the central data foundation of the SensorUp platform. It solves the data chaos problem by integrating, managing, and contextualizing information from unlimited sources, **so your team can spend time reducing emissions rather than chasing and organizing data.**
> [accordion] CA-1 Platform: Centralize Your Data for Real-Time Insights
>
> The **CA-1 Platform** is the essential starting point for any emissions management program. It creates a single source of truth, driving accountability and consistent action in responding to significant methane leaks.
>
> * **Build a Complete Asset Digital Twin:** Go beyond simple lists and create a rich, hierarchical model of your entire operational landscape—from facilities, CPFs, and CGLs down to individual equipment and components—using our flexible GraphQL API.
> * **Unify All Your Datastreams:** Solve data silos by seamlessly integrating data from leading third-party providers (InsightM, Qube, Bridger, CarbonMapper, etc.) and your own cloud environments (AWS, Azure, FTP).
> * **Transform Raw Detections into Actionable Events:** We turn a noisy stream of alerts into clear, managed Emission Events. Our platform automatically correlates related detections, estimates event start/end times and rates, and allows you to attribute emissions to specific physical sources, providing the clarity needed to make informed decisions.
> [accordion] CA-3 Contextualization Add-On: Prioritize with Purpose and Context
>
> **The Problem:** You receive endless alerts from sensors, but without context, your teams suffer from alarm fatigue and can't distinguish between actual leaks, operational challenges, and routine events. This leads to wasted resources and distracts teams from real issues.
>
> **Our Solution:** The **CA-3 Contextualization Add-On** solves this by overlaying your operational data (from SCADA, work orders, flaring notifications, production volumes) on top of your emissions data. This enriches every emission event with crucial context, or "Clues," enabling faster root cause analysis.
>
> > [!NOTE]
> >
> > **Success Story:** Oxy reduced unscheduled site visits by 35%. By integrating SCADA and operations logs, their operators can now confidently determine if an emission is from venting, blowdown, or a true fugitive source, preventing unnecessary dispatches and increasing safety by reducing driving time.
>
> *Requires CA-1 Platform.*
> [accordion] CA-2 Insights Add-On: Use Long-Term Trends to Minimize Loss
>
> **The Problem:** Emissions are a signal of larger operational problems, but without the ability to analyze long-term trends across siloed datasets, operations managers are missing opportunities to remedy inefficiencies and address recurring issues.
>
> **Our Solution:** The **CA-2 Insights Add-On** provides user-friendly visualization tools to identify short-, medium-, and long-term trends. By correlating historical emissions data with process data, you can identify clear patterns, prioritize maintenance, and use data to eliminate repeat issues that may not be immediately discernible. *Requires CA-1 Platform.*
> [accordion] Non-Detections: Using Nothing to Prove Everything
>
> **The Problem:** Snapshot emissions data doesn't tell the whole story. You struggle to "bookend" emission events to understand their true duration and can't tell if a leak is persistent or intermittent.
>
> **Our Solution:** The SensorUp platform intuitively provides non-detect data from your survey programs as critical context. We use non-detection information in a timeline view to help assign potential start and end dates to emission events, providing a more accurate, longitudinal view of your emissions profile and reducing uncertainty in your inventory. This is a core capability of our data model within the **CA-1 Platform**.
## Connected Operations
**Challenge:** The ultimate goal is **emissions reduction**, but that goal is often lost in the operational gap between detection and action. Companies invest heavily in advanced measurement technologies, but without a connected system, that data fails to trigger a fast, efficient response. This disconnect leads to prolonged leaks, inefficient field dispatch, and a failure to capitalize on the full value of your measurement campaigns, making it difficult for field operations to buy into new programs.
**Our Solution:** Connected Operations closes the loop between insight and action. It streamlines and automates your field service workflows, ensuring that every emission event is managed efficiently from start to finish.
> [accordion] CO-1 Standard: Your Workflow & Integration Engine
>
> The **CO-1 Standard** package provides the core automation and integration engine to dispatch your teams smarter and faster.
>
> * **Automate Your Response Plans:** Instead of manual emails and phone calls, design and trigger standardized procedures directly from an emission event. Whether it's a Super Emitter Response Plan or a simple operational comment, ensure consistent, auditable actions every time.
> * **Derisk Your Technology Adoption:** Your teams are already trained on systems like SAP and Maximo. Instead of forcing a disruptive change, we integrate with your existing work order systems. This reduces barriers for air quality teams to launch new programs and controls change management risk for field operations, ensuring smoother adoption.
> * **Visualize Your Operational Status:** Use the Operations Dashboard to get a real-time, at-a-glance view of all active procedures and their current state.
> [accordion] CO-2 Outpost Add-On: Empowering Your Field Teams
>
> **The Problem:** Field technicians are burdened with clunky tools, paper forms, and limited connectivity, leading to slow, inaccurate data capture that makes follow-up reporting difficult.
>
> **Our Solution:** The **CO-2 Outpost Add-On** is our powerful mobile app that empowers field crews to input repair details and report events, even with limited connectivity. Information from the field flows directly back to the leak events in the central platform, reducing reporting timelines and ensuring data is available for future analysis. *Requires CO-1 Standard.*
>
> > [!NOTE]
> >
> > **Success Story:** A client streamlined their manual work order process, reducing leak event reporting timelines by 30%. By automating triggers and providing field crews with the Outpost app, they improved the flow of information, giving teams more context to triage events and a clear pathway for reporting.
## Connected Markets
**Challenge:** Emissions accounting and reconciliation is no longer just an annual exercise—it's a high-stakes process critical for regulatory compliance (OGMP 2.0, BCER, AER), voluntary certification (MiQ), and investor confidence. VPs of Ops and ESG struggle to reconcile disparate inventories and report numbers with certainty.
**Our Solution:** Connected Markets is your comprehensive accounting and reporting suite, providing the tools and workflows you need for confident compliance and to turn your environmental data into a strategic asset.
> [accordion] CM-1 Standard: Your Reconciliation & Accounting Foundation
>
> The **CM-1 Standard** package provides the foundational tools to solve the core challenge of emissions accounting: building a reliable, auditable system of record.
>
> * **Build a Defensible Inventory:** Go beyond simple estimates by creating a detailed source-level (bottom-up) inventory and integrating direct site-level measurements (top-down) from quantification studies.
> * **Perform Robust Reconciliation:** Don't just report two numbers; truly reconcile them. Our engine supports multiple methods (hybrid, measurement-informed) and helps you understand and manage site-level uncertainty.
> * **Prepare for Diverse Reporting Needs:** Our platform provides the foundational data structures and reconciliation engine to support a wide range of reporting needs, from regulatory compliance like BCER and AER to voluntary programs like OGMP 2.0 and certifications like MiQ.
> * **Establish an Auditable System of Record:** Move your emissions accounting out of spreadsheets and into a transparent system with built-in workflows for internal review and month-end close processes, ensuring your numbers are always audit-ready.
> [accordion] CM-2 OGMP Assist Add-On: Mastering OGMP 2.0 Reporting
>
> **The Problem:** Meeting OGMP 2.0 Level 4/5 reporting requirements, especially
> analyzing and explaining discrepancies between inventories, is a major hurdle
> for air quality specialists. **Our Solution:** The **CM-2 OGMP Assist Add-On**
> provides purpose-built tools to master this challenge. It includes guided
> discrepancy analysis workflows and reporting templates that simplify the
> process of generating compliant OGMP 2.0 reports, saving hundreds of hours of
> manual effort. *Requires CM-1 Standard.*
> [accordion] CM-3 & CM-4: Certification & Carbon Market Readiness
>
> **The Problem:** Participating in certification programs like MIQ or carbon markets requires an exceptionally high standard of data quality, verification, and evidence submission.
>
> **Our Solution:** Our advanced Markets add-ons prepare you for this future. The **MIQ Assist Add-On** (Coming Soon) will provide a guided walkthrough of certification requirements. The **CDR Assist Add-On** provides dashboards to characterize your carbon performance and will feature integrations with leading verifiers and registries to streamline evidence submission. *Requires CM-1 Standard.*
## Connected Platform & Services
Underpinning all solutions are our robust platform services for enterprise-grade security and user management, along with expert support to ensure your success.
> [accordion] Connected Platform: The Enterprise-Grade Foundation
>
> All SensorUp solutions are built on a secure, scalable, and enterprise-ready
> platform. This provides peace of mind by offering robust user management,
> granular role-based access controls, and integrations with your existing
> identity providers (SSO) and security tools (SIEM).
> [accordion] Connected Services: Your Partner in Success
>
> Technology is only part of the solution. Our Connected Services provide the
> human expertise to ensure you achieve your goals, with tiered packages for
> both integration support during onboarding and ongoing technical support to
> match your organization's needs.
# Asset Status
Source: https://docs.sensorup.com/use-sensorup/assets/asset-status
Track and manage the operational status of assets for accurate reporting and reconciliation, ensuring audit-ready data.
## What is Asset Status?
Asset Status is a comprehensive tracking system that maintains a complete historical record of each asset's operational state over time. This capability is essential for generating accurate, audit-ready reports and ensuring compliance with regulatory standards by automatically excluding inactive periods from emissions calculations.
> [card] Audit-Ready Reports
>
> Defensible compliance records
> [card] Automated Reconciliation
>
> Accurate emission calculations
> [card] Complete History
>
> Full operational timeline
## Why Use Asset Status?
> [card] The Problem
>
> **Without asset status tracking:**
>
> * Manual reconciliation of operational data is time-consuming and error-prone
> * Emissions reports include periods when assets weren't active
> * No audit trail for status changes and compliance decisions
> * Risk of inaccurate reporting that's vulnerable to regulatory scrutiny
> [card] The Solution
>
> **With Asset Status:**
>
> * Automated tracking creates a single source of truth for asset operations
> * Reports automatically exclude inactive periods for accuracy
> * Complete audit trail for all status changes with user attribution
> * Confidence in regulatory submissions with defensible data
## Core Capabilities
> [accordion] Understanding Status Categories
>
> Asset Status standardizes all operational states into two clear categories, ensuring consistent reporting across all data sources.
>
> **ACTIVE**
>
> * Asset is active and functioning as expected
> * Includes statuses like: Active, Limited Use, Available, Online
> * Emissions from these periods are included in reports
>
> **INACTIVE**
>
> * Asset is inactive or cannot be used
>
> * Includes statuses like: Broken, Decommissioned, Inactive, Missing, Offline, Maintenance
>
> * Emissions from these periods are automatically excluded from reports
>
> > [!NOTE]
> >
> > **Smart Mapping:** The system preserves your original terminology while standardizing for reporting. For example, if your system shows "Under Maintenance," it's stored as your original term but standardized to INACTIVE for consistent reporting.
> [accordion] Status Fields and Information
>
> Each status entry contains comprehensive information for audit and compliance purposes:
>
> | Field | Description | Purpose |
> | - | - | - |
> | **Status** | Standardized category (ACTIVE/INACTIVE) | Primary field for filtering and reporting |
> | **External Status** | Original status from your source system | Preserves your terminology |
> | **Start Date/Time** | When this status became active | Defines operational periods |
> | **End Date/Time** | When this status ended (empty = current) | Defines operational periods |
> | **Status Reason** | Explanation for the status change | Audit trail and context |
> | **Is Inferred** | Whether explicitly set or automatically inferred | Data quality indicator |
> [accordion] Automated vs Manual Management
>
> Asset Status supports both automated integration and manual control for complete flexibility.
>
> ### Automatic via Integration
>
> * Primary method for status updates
> * Syncs directly from your operational systems (Maximo, SAP, etc.)
> * Automatically maps your statuses to standard categories
> * Creates historical log as reported by source systems
>
> ### Manual Override by Administrators
>
> * Administrator role required for manual changes
>
> * Set specific date ranges for status periods
>
> * Add reasons for audit purposes
>
> * Handle corrections or missing periods
>
> > [!WARNING]
> >
> > **Temporal Validation:** Status periods cannot overlap. Any ongoing status must be ended before adding a new status for a more recent period.
## Common Use Cases
**Excluding Sold Assets from Reports**
When assets are sold or permanently decommissioned, mark them as INACTIVE from the sale date forward to ensure they don't contribute to ongoing emissions totals.
**Managing Temporary Shutdowns**
For planned maintenance or temporary closures, set INACTIVE status for specific date ranges to accurately reflect when assets were inactive and not contributing to emissions.
**Compliance Reporting**
Generate reports that automatically exclude inactive periods, providing regulators with accurate data that reflects your actual operational footprint.
## Managing Asset Status
### Manual Status Management
> [tab] Setting Status Periods
>
> **1. Navigate to Asset**
>
> From the **Assets** tab, click on the asset you want to update to open its details page.
>
> **2. Access Status Tab**
>
> Select the **Status** tab to view current and historical status information.
>
> **3. Add Status Period**
>
> Click **Add dates** to create a new status period.
>
> **4. Configure Status**
>
> * Select **ACTIVE** or **INACTIVE**
> * Enter a **Reason** for audit purposes
> * Set **Start Date** and **End Date** (leave end date empty for ongoing status)
> * Click **Save**
> [tab] Viewing Audit Trail
>
> **1. Access Status History**
>
> In the asset's **Status** tab, view the complete timeline of status changes.
>
> **2. Review Change Details**
>
> Each entry shows:
>
> * Who made the change
> * When it was made
> * Reason provided
> * Original source (manual vs. automatic)
>
> **3. Export for Compliance**
>
> Use the export function to generate audit reports for regulatory submissions.
### Automated Status Integration
> [!NOTE]
>
> **Future Capability:** Automated status synchronization from operational systems is available through backend configuration. Contact your SensorUp team for setup assistance.
**Integration Capabilities:**
* Direct API integration with operational systems
* Custom status mapping from source systems
* Real-time status updates
* Comprehensive audit trails
## Using Status for Reporting
Asset Status automatically integrates with your reporting workflows to ensure accuracy and compliance.
**Automated Report Filtering**
* Emissions reports automatically exclude INACTIVE periods
* Historical data reflects accurate operational timelines
* Compliance reports include complete audit trails
**Report Accuracy Benefits**
* No manual data adjustments needed
* Defensible data for regulatory submissions
* Complete operational context for auditors
## FAQ / Troubleshooting
> [accordion] Why are some status periods marked as 'inferred'?
>
> When no explicit status exists for a time period, the system automatically infers ACTIVE status to ensure complete temporal coverage. The `isInferred` flag helps you identify these periods for data quality assessment.
> [accordion] Can I edit or delete existing status periods?
>
> Administrator users can modify status periods, but temporal validation prevents overlapping periods. You must end an ongoing status before adding a new one for a more recent time period.
> [accordion] How does status affect my emissions reports?
>
> Emissions data from periods when assets are marked as INACTIVE are automatically excluded from calculations, ensuring your reports reflect only active operational periods.
> [accordion] What happens if I don't set any status for an asset?
>
> Assets without explicit status records are considered ACTIVE by default. The system fills any gaps in status history with inferred ACTIVE periods to ensure complete coverage.
> [accordion] How do I set up automated status updates from our operational systems?
>
> Automated status integration is available through backend configuration. Contact your SensorUp support team to discuss integration with systems like Maximo or SAP and set up the necessary API connections.
**Technical Implementation Details**
## System Architecture
Asset Status uses a dual-storage approach optimized for different query patterns:
* **Real-time Updates:** DynamoDB for single asset queries and immediate status changes
* **Analytics & Reporting:** Parquet/Delta Lake for high-performance list queries and historical analysis
## Data Quality Assurance
* **Temporal Consistency:** Automatic validation prevents overlapping status periods
* **Audit Trail:** Complete change history with user attribution
* **Gap Filling:** Automatic inference ensures no missing periods in reports
* **Performance Optimization:** Smart caching and parallel processing for large datasets
This architecture ensures reliable, audit-ready data while maintaining excellent query performance across diverse operational environments.
## Key Benefits
> [!TIP]
>
> **Regulatory Confidence**
Submit emissions reports with complete confidence, knowing your data accurately reflects operational reality and includes comprehensive audit trails.
> [!TIP]
>
> **Automated Accuracy**
Eliminate manual spreadsheet adjustments and reduce errors by automatically excluding non-operational periods from all calculations and reports.
> [!TIP]
>
> **Complete Transparency**
Maintain full visibility into all status changes with detailed audit trails, ensuring preparedness for regulatory audits and internal reviews.
> [!TIP]
>
> **Operational Efficiency**
Reduce administrative overhead with available automated status integration while maintaining the flexibility for manual overrides when needed.
***
## Next Steps
> [card] [Assets Model](/use-sensorup/assets/assets-model)
>
> Understand the complete asset data model and how operational status integrates with other asset properties.
> [card] [Getting Started with Assets](/use-sensorup/assets/getting-started)
>
> Learn the fundamentals of asset management and begin implementing status tracking workflows.
> [card] [System Integration](/use-sensorup/user-management/getting-started-integrations)
>
> Learn about integrating with your operational systems for automated status management.
# Data Model: CAM Asset Model
Source: https://docs.sensorup.com/use-sensorup/assets/assets-model
The complete data dictionary for the Connected Asset Management (CAM) Model, detailing how core assets and customer-provided extensions are stored and linked.
This document describes the **CAM Model**, which creates a unified and extensible representation of various company assets. The model is built on two primary storage partitions in the database: one for the **Core Asset State** and others for customer-provided **Asset Extensions**.
The processes of **DUMP** (syncing to S3) and **seedSync** (ingesting and linking data) ensure data integrity and performance.
***
## Partition 1: Core Asset State
This partition (``) holds the core, enriched properties of an asset, serving as the central record. It is built by combining foundational data with synced information from various extensions.
> [accordion] assetId — Asset ID
>
> * **Description**: The unique, system-generated primary key (sort key) for each asset record across all partitions.
> * **Data Type**: `UUID`
> * **Example**: `a1b2c3d4-e5f6-7890-1234-567890abcdef`
> [accordion] Core Properties (id, name, etc.)
>
> * **Description**: Standard, foundational attributes of any asset, such as its name and hierarchical references.
> * **Data Type**: Varies (`String`, `Integer`, etc.)
> * **Notes**: Includes default properties and any attributes defined through mutations.
> [accordion] Connection Properties (e.g., suSiteId, FLOC)
>
> * **Description**: A property that links the core asset to its extension data. It is created on the core asset using the `stateProperty` defined in an extension's `connectionDetails`. This field holds the value that is used to join with the extension's `idProperty`.
> * **Data Type**: `String`
> * **Example**: `FLOC-12345`
> [accordion] Enriched Properties (from stateProperties)
>
> * **Description**: Core asset properties that are populated or "enriched" by data from an extension dataset, as defined in the extension's `stateProperties` mapping. This allows customer data to fill in the asset's official state.
> * **Data Type**: Varies (`String`, `Integer`, `Float`)
> * **Example**: The `name` field might be populated from a `SAP_FUNCTIONAL_LOCATION_DESCRIPTION` column in a customer's dataset.
> [accordion] geometry — GeoJSON Geometry
>
> * **Description**: The official GeoJSON geometry for the asset. This property is populated from the column specified in an extension's `geometryColumn` definition.
> * **Data Type**: `String` (GeoJSON)
> * **Example**: `"{ 'type': 'Point', 'coordinates': [-104.9903, 39.7392] }"`
> [accordion] Component-Defined Properties (e.g., isAttributable)
>
> * **Description**: Fields added and managed by other internal components or backend services that interact with the asset model.
> * **Data Type**: Varies (`Boolean`, `String`)
***
## Partition 2+: Asset Extensions
Each extension has a dedicated partition (`:`) that stores the raw, unmodified data provided by the customer. This data is read-only within the CAM model and serves as the source for enriching the Core Asset State.
> [accordion] assetId — Asset ID
>
> * **Description**: The unique primary key (sort key) that links the extension record back to the corresponding record in the Core Asset State partition. This ID is established during the `seed` and `seedExtension` processes.
> * **Data Type**: `UUID`
> * **Example**: `a1b2c3d4-e5f6-7890-1234-567890abcdef`
> [accordion] Extension Data Properties
>
> * **Description**: All other columns and values provided in the customer's source dataset for the extension. These fields are not directly mutable and reflect the customer's data "as-is."
> * **Data Type**: Varies (Depends on customer data)
> * **Notes**: The specific fields in this partition are dynamic and match the schema of the customer's source file. The `seedSync` process uses this data to update the Core Asset State.
# Asset Audit History
Source: https://docs.sensorup.com/use-sensorup/assets/auditing-changes-for-assets
Complete audit trail tracking all changes to assets and their operational status for regulatory compliance and troubleshooting.

## What is Asset Audit History?
Asset Audit History provides a comprehensive, immutable record of every change made to your assets and their operational status. This complete audit trail ensures regulatory compliance, enables troubleshooting, and provides full transparency into who made what changes and when.
> [card] Complete Audit Trail
>
> Every change tracked and logged
> [card] Regulatory Compliance
>
> Audit-ready documentation
> [card] Full Transparency
>
> Know who changed what and when
## Why Use Asset Audit History?
> [card] The Problem
>
> **Without audit history tracking:**
>
> No visibility into who changed asset data or status
>
> Can't investigate why assets are excluded from reports
>
> No compliance trail for regulatory audits
>
> Risk of unauthorized changes going unnoticed
> [card] The Solution
>
> **With Asset Audit History:**
>
> Complete record of all asset and status changes
>
> Clear audit trail showing who, what, when
>
> Quick investigation of data changes
>
> Audit-ready compliance documentation
## Core Capabilities
> [accordion] Track All Asset Changes
>
> Asset Audit History automatically captures every change to your assets, including:
>
> **Asset Property Changes**
>
> * Asset creation and initial configuration
> * Updates to asset properties (name, location, type, etc.)
> * Changes to extension properties and custom fields
> * Asset geometry modifications
> * Asset type changes
>
> **Status Changes**
>
> * Status creation (initial operational status)
>
> * Status updates (active/inactive transitions)
>
> * Status deletion (removal of status periods)
>
> * Status overlap resolution
>
> > [!NOTE]
> >
> > **Automatic Tracking:** All changes are automatically recorded by the system - no manual logging required. The audit trail is immutable and cannot be altered after creation.
> [accordion] Detailed Change Information
>
> Each audit entry provides comprehensive information for investigation and compliance:
>
> | Field | Description | Purpose |
> | - | - | - |
> | **Event Type** | Type of change (Created, Updated, Deleted, etc.) | Understand what action occurred |
> | **Event Time** | Precise timestamp of the change | Track when changes happened |
> | **User** | Who made the change (user ID and name) | Accountability and investigation |
> | **Property Changes** | Detailed before/after values for each property | See exactly what changed |
> | **Status Changes** | Complete status change history by status ID | Track operational status transitions |
> | **Version** | Sequential version number | Understand change sequence |
> | **Correlation ID** | Link related changes together | Track bulk operations |
> [accordion] Property-Level Change Tracking
>
> See exactly what changed with detailed before-and-after comparison:
>
> ### Old and New Values
>
> * **Old Value**: The property value before the change (null for newly created properties)
> * **New Value**: The property value after the change (null for deleted properties)
> * **Property Type**: Data type (string, number, boolean, datetime, geometry, JSON)
>
> ### Property Source Identification
>
> * **Asset Properties**: Grouped by asset type (site, well, facility, etc.)
>
> * **Status Properties**: Grouped by status ID for status changes
>
> * **Extension Properties**: Custom fields and extensions tracked separately
>
> > [!WARNING]
> >
> > **Status Changes:** When an asset is set to "Inactive," the audit history provides the critical trail showing who made the change and when, explaining why detections from that asset are excluded from reports.
## Common Use Cases
**Investigating Excluded Assets**
When an asset's detections aren't appearing in reports, check the audit history to see who set it to "Inactive" status and when. This helps you understand whether the exclusion is correct or needs to be addressed.
**Regulatory Compliance**
Generate complete audit trails showing all asset and status changes for regulatory submissions. The immutable audit log provides defensible documentation for compliance audits.
**Troubleshooting Data Issues**
When asset data appears incorrect or inconsistent, review the audit history to see what changes were made, by whom, and when. This helps identify the source of data issues quickly.
**Tracking Integration Changes**
Monitor changes made by system integrations (marked as "System" user) to ensure your source-of-truth systems are correctly synchronizing asset data.
**Annual Data Audits**
Review the complete history of asset status changes and property updates to maintain comprehensive compliance records and verify data integrity.
## Viewing Asset Audit History
> [!NOTE]
>
> **Access Requirements:** Audit history is available to all authenticated users who have permission to view the asset.
**1. Navigate to Asset**
From the **Assets** section, select the asset you want to investigate to open its details page.
**2. Access History Tab**
Select the **History** tab to view the complete audit trail for this asset.
> [!NOTE]
>
> The history shows all changes in reverse chronological order (most recent first).
**3. Review Change Details**
Each audit entry shows:
* **What Changed**: Event type and property changes
* **When**: Precise timestamp of the change
* **Who**: User who made the change (or "System" for automated changes)
* **Details**: Before and after values for each changed property
**4. Filter Results (Optional)**
Use filters to narrow down the audit trail:
* Filter by event type (e.g., only status changes)
* Filter by date range (e.g., changes in last quarter)
* Filter by user (e.g., changes by specific person)
### Understanding Change Events
> [tab] Asset Changes
>
> **ASSET\_CREATED**
>
> * Recorded when an asset is first created
> * Shows all initial property values
> * Old values are null (no previous state)
>
> 
>
> **ASSET\_UPDATED**
>
> * Recorded when any asset property is modified
> * Shows before and after values for changed properties
> * Includes property name, type, and source partition
>
> 
>
> **ASSET\_DELETED**
>
> * Recorded when an asset is removed
> * Shows all final property values
> * New values are null (no new state)
> [tab] Status Changes
>
> **STATUS\_CREATED**
>
> * Recorded when a new status period is added
> * Shows all status properties (start date, end date, reason, etc.)
> * Critical for understanding when assets became active/inactive
>
> **STATUS\_UPDATED**
>
> * Recorded when an existing status period is modified
> * Shows before and after values for changed status properties
> * Includes status ID for identifying which period changed
>
> **STATUS\_DELETED**
>
> * Recorded when a status period is removed
>
> * Shows all properties of the deleted status
>
> * Provides audit trail for removed status periods
>
> > [!NOTE]
> >
> > **Key Insight:** Status changes are grouped by status ID, making it easy to track the complete lifecycle of each operational status period.
> [tab] System vs User Changes
>
> **System Changes**
>
> * Made by automated integrations
> * User shown as "System" or integration name
> * Typically property updates from source systems
>
> **User Changes**
>
> * Made by authenticated users
> * Shows user ID and full name
> * Typically manual updates or status changes
>
> **Critical Status Changes**
>
> * Setting assets to "Inactive" (most important user action)
> * Creates audit trail explaining why detections are excluded
> * Essential for compliance and troubleshooting
## Using Audit History via API
> [accordion] GraphQL Query Examples
>
> ### Query Asset Audit History
>
> ```graphql theme={null}
> query GetAssetAuditHistory($assetId: ID!, $assetTypeId: ID!) {
> asset(id: $assetId, assetTypeId: $assetTypeId) {
> id
> name
> auditing {
> history(
> assetId: $assetId
> assetTypeId: $assetTypeId
> filter: {
> eventTypes: [ASSET_UPDATED, STATUS_UPDATED]
> fromTime: "2024-01-01T00:00:00Z"
> toTime: "2024-12-31T23:59:59Z"
> }
> ) {
> eventType
> version
> eventTime
> user {
> userId
> userName
> }
> correlationId
> assetPropertyChanges {
> propertySourcePartition
> propertyName
> propertyType
> oldValue {
> ... on StringValue { value }
> ... on NumberValue { value }
> ... on BooleanValue { value }
> }
> newValue {
> ... on StringValue { value }
> ... on NumberValue { value }
> ... on BooleanValue { value }
> }
> }
> statusChanges {
> id
> propertyChanges {
> propertyName
> propertyType
> oldValue { ... on StringValue { value } }
> newValue { ... on StringValue { value } }
> }
> }
> }
> }
> }
> }
> ```
>
> ### Query Only Status Changes
>
> ```graphql theme={null}
> query GetAssetStatusHistory($assetId: ID!, $assetTypeId: ID!) {
> asset(id: $assetId, assetTypeId: $assetTypeId) {
> id
> auditing {
> history(
> assetId: $assetId
> assetTypeId: $assetTypeId
> filter: {
> eventTypes: [STATUS_CREATED, STATUS_UPDATED, STATUS_DELETED]
> }
> ) {
> eventType
> eventTime
> user {
> userName
> }
> statusChanges {
> id
> propertyChanges {
> propertyName
> oldValue { ... on StringValue { value } }
> newValue { ... on StringValue { value } }
> }
> }
> }
> }
> }
> }
> ```
>
> > [!NOTE]
> >
> > **GraphQL Federation:** Asset Audit History is available through the GraphQL API with full federation support. See [GraphQL API documentation](/api/graphql/overview) for authentication and query details.
## FAQ / Troubleshooting
> [accordion] Why don't I see any audit history for my asset?
>
> Assets created before the audit history feature was implemented may not have historical data. The system automatically initializes audit tracking when you first access the history for legacy assets, creating a baseline event. All changes going forward will be tracked.
> [accordion] How do I find out who set my asset to Inactive?
>
> 1. Go to the asset's **History** tab
> 2. Filter by event type: **STATUS\_CREATED** or **STATUS\_UPDATED**
> 3. Look for entries where the status changed to "INACTIVE"
> 4. The **User** field shows who made the change
> 5. The **Event Time** shows exactly when it happened
> 6. Review **Property Changes** to see the status reason
>
> This information is critical for understanding why an asset's detections are excluded from reports.
> [accordion] Can audit history entries be modified or deleted?
>
> No. The audit trail is immutable by design. Once a change is recorded, it cannot be altered or deleted. This ensures the integrity of your audit records for regulatory compliance and forensic investigation.
> [accordion] What's the difference between 'System' and user changes?
>
> * **System changes**: Made by automated integrations syncing data from your source-of-truth systems (e.g., Maximo, SAP). Most asset property updates come from these integrations.
> * **User changes**: Made by authenticated users manually updating asset data or status. The most important user action is setting assets to Active/Inactive status.
> [accordion] How far back does the audit history go?
>
> For assets created after the audit history feature was deployed, the complete history is available from the asset's creation. For legacy assets, history begins when the audit system was initialized for that asset (typically when first accessed) or when the audit history feature was activated.
> [accordion] Why do some changes show 'null' for old or new values?
>
> * **Old value is null**: The property was newly created (e.g., ASSET\_CREATED event or new property added)
> * **New value is null**: The property was deleted (e.g., ASSET\_DELETED event or property removed)
> * This is normal and helps distinguish between creation, updates, and deletions
> [accordion] What is a 'correlation ID' and why does it matter?
>
> A correlation ID links related changes together, especially during bulk operations or batch imports. When you see the same correlation ID on multiple audit entries, it means those changes were part of the same operation or transaction. This helps you understand the context of changes.
> [accordion] Can I export audit history for compliance reporting?
>
> Yes. You can use the GraphQL API to query audit history and export the data to your preferred format for compliance reporting. The API provides complete access to all audit trail information including timestamps, users, and property changes.
**Technical Implementation Details**
## System Architecture
Asset Audit History uses an **event sourcing pattern** with immutable event logs:
* **Event Store:** DynamoDB table stores all audit events as immutable records
* **Automatic Tracking:** Every asset mutation automatically creates audit events
* **Event Types:** Comprehensive coverage of all asset and status lifecycle events
* **Property-Level Changes:** Detailed before/after tracking for every property
* **Performance Optimized:** Efficient querying with indexed event streams
## Event Sourcing Benefits
* **Complete History:** Every state change is preserved permanently
* **Immutable Records:** Audit trail cannot be altered after creation
* **Temporal Queries:** Query asset state at any point in time
* **Compliance Ready:** Audit trail meets regulatory requirements
* **Debugging Power:** Full history available for troubleshooting
## Data Retention
Audit history is retained indefinitely by default. All events are stored in the event store with:
* Sequential version numbers for ordering
* Precise timestamps for temporal analysis
* Complete property change information
* User attribution and correlation IDs
This architecture ensures reliable, audit-ready data while maintaining excellent query performance.
## Key Benefits
> [!TIP]
>
> **Regulatory Confidence**
Meet regulatory requirements with complete, immutable audit trails documenting every asset and status change with full user attribution.
> [!TIP]
>
> **Quick Investigation**
Rapidly troubleshoot data issues by reviewing exactly what changed, who made the change, and when it occurred, eliminating guesswork.
> [!TIP]
>
> **Data Integrity**
Ensure accountability and prevent unauthorized changes with comprehensive tracking of all asset modifications and status updates.
> [!TIP]
>
> **Transparency**
Provide full visibility into asset data lifecycle for auditors, compliance officers, and operational teams with detailed change history.
***
## Next Steps
> [card] [Asset Status](/use-sensorup/assets/asset-status)
>
> Learn about managing operational status and how status changes appear in audit history.
> [card] [Assets Model](/use-sensorup/assets/assets-model)
>
> Understand the complete asset data model and what properties are tracked in audit history.
> [card] [GraphQL API](/api/graphql/guides/cam-assets)
>
> Access audit history programmatically through the GraphQL API for custom integrations.
# Getting Started: Mastering Your Connected Assets
Source: https://docs.sensorup.com/use-sensorup/assets/getting-started
Learn to define, manage, and visualize your asset hierarchies in SensorUp's Connected Assets module. Understand asset IDs, lifecycles, hierarchy views, and their role in contextualizing observations.
# Getting Started with Connected Assets
Welcome to SensorUp's Connected Assets module! This is where you define, organize, and manage the digital representations of all your physical and logical entities. A well-structured asset registry is the foundation for accurate emissions tracking, contextual data analysis, and streamlined operational workflows across the entire SensorUp platform.
> [!NOTE]
>
> Connected Assets allows you to build a comprehensive digital twin of your operational landscape—from individual components and equipment within a CPF or CGL, to entire facilities and wells—and understand their relationships and status over time.
## What is an Asset in SensorUp?
In SensorUp, an **Asset** represents any physical or logical entity that you need to track, manage, or associate data with. This can include:
* **Facilities:** Such as a Central Processing Facility (CPF), Central Gas Lift (CGL), or a well site.
* **Equipment:** Pumps, compressors, separators, tanks, flares, engines located within a facility.
* **Components:** Motors, seals, valves that are parts of larger equipment.
* **Wells:** Production wells, injection wells, or disposal wells.
* **Linear Assets:** Pipeline segments.
* **Locations & Areas:** Specific operational areas, measurement points, or inspection zones.
## Core Capabilities of Connected Assets
Connected Assets provides a rich set of features to manage your asset information effectively:
> [accordion] Comprehensive Asset Definition & Identification
>
> Define detailed information for each asset and identify them uniquely within SensorUp and in relation to your external systems.
>
> * **Core Asset Attributes:** Define essential properties like `name`, `description`, and `assetType` (e.g., "CPF", "Pump", "Well").
> * **Dual ID System:**
> * **`assetId` (Internal ID):** A system-generated, unique, and unchangeable identifier (UUID) used by SensorUp for all internal references. This is the primary key within the platform.
> * **`externalIds` (External IDs):** A flexible list of your own identifiers (e.g., ERP IDs, legacy asset tags, Functional Location Codes - FLOCs). Each external ID has a `type` (e.g., "FLOC\_5\_PART", "SERIAL\_NO") and a `value`. These can be updated and used for integration with your existing systems.
> * **Detailed Characteristics:** Capture rich metadata such as `manufacturer`, `modelNumber`, `serialNumber`, `installationDate`, and custom key-value `customProperties` specific to your needs.
> * **Tagging:** Apply descriptive `tags` (e.g., "critical-facility", "gas-processing", "area-A") for easier searching, filtering, and grouping.
> [accordion] Asset Lifecycle Management
>
> Track and manage the complete lifecycle of your assets from creation to disposal.
>
> * **Status Tracking:** Assign a clear operational `status` to each asset (e.g., `DRAFT`, `PENDING_ACTIVATION`, `ACTIVE`, `INACTIVE`, `MAINTENANCE`, `DECOMMISSIONED`).
> * **Activation & Inactivation Dates:**
> * `activeDate`: The date and time when an asset becomes (or became) operational.
> * `inactiveDate`: The date and time when an asset is no longer operational or is taken out of service.
> * **Reason for Inactivity:** Optionally record an `inactiveReason` for assets that are not active.
> * **Versioning & Audit Trail:** Track changes to asset information over time with `createdAt`, `updatedAt`, and `version` fields.
> [accordion] Hierarchical Asset Structuring
>
> Organize your assets into logical hierarchies to represent physical assemblies (like equipment within a CPF), functional systems, or spatial relationships.
>
> * **Parent-Child Relationships:** Define hierarchies by assigning a `parentId` to an asset, linking it to another asset (e.g., a "Pump" asset linked to its parent "CPF" asset). Assets with no `parentId` are top-level.
> * **Global Asset Hierarchy:** All parent-child links form a comprehensive structure of your entire asset ecosystem.
> * **Location Context:** Associate assets with `location` information (geographic coordinates, civic addresses).
> \[!NOTE] Hierarchical relationships are primarily managed via `parentId`. Use `location.properties` for descriptive attributes of a coordinate, not for defining hierarchy.
> [accordion] Flexible Hierarchy Views & Traversal
>
> View and interact with specific portions or perspectives of your global asset hierarchy.
>
> * **Dynamic Hierarchy Traversal:** Query the global hierarchy starting from any asset (e.g., a specific CGL), navigate up or down to a specified `depth`, and see summarized child counts for levels beyond the query depth.
> * **Named Hierarchy Views:** Define, save, and reuse specific "views" of the hierarchy. A named view can pre-set parameters like a starting `rootAssetId` (e.g., a particular facility) and a default `depth`, simplifying access to commonly used perspectives.
> [accordion] Context for Observations & Measurements
>
> Connected Assets provides the essential context for sensor data, inspection results, and other observations.
>
> * **Asset as the Subject of Observation (FeatureOfInterest):** Each managed Asset in Connected Assets is typically the "thing" an observation is about (often referred to as the FeatureOfInterest). The asset's `assetId` (or a dedicated `featureOfInterestId` if used by your observation system) is the unique identifier linking observations to the specific asset they describe.
> * **Enriching Sensor Data:** While time-series observation data is managed in SensorUp Datastreams, Connected Assets provides the crucial metadata (name, type, location, status, hierarchical relationships of a well, piece of equipment, or facility) to understand and interpret these observations correctly.
> * **Standardized Asset Typing:** Use consistent `assetType` values and `customProperties` to map to your internal or industry-specific asset classifications, enhancing data interoperability.
> [accordion] API-Driven Management (GraphQL Focused)
>
> Programmatically manage your assets through a robust GraphQL API.
>
> * **Core CRUD Operations:** Create, read (retrieve by `assetId` or query lists with filters), update, and delete (decommission) assets such as facilities, equipment, or components.
> * **Hierarchy Queries:** Specifically query the `assetHierarchy` starting from root assets or named views, controlling depth and filtering.
> * **Named View Management:** Create, read, update, and delete `NamedHierarchyView` definitions.
> * **Bulk Operations:** Perform `bulkCreateAssets`, `bulkUpdateAssets`, and `bulkDeleteAssets` for efficient management.
> \[!NOTE] While this guide focuses on concepts, detailed GraphQL schema, queries, and mutations are available in the [Connected Asset Management API Reference](/api/graphql/subgraphs/assets).
## Conceptual Workflow: Building Your Asset Registry
Here's a typical process for establishing and managing your assets—from facilities down to components—in SensorUp:
### 1. 1. Define Asset Types & Attributes
Identify the different types of assets you need to manage (e.g., "CPF", "CGL", "Well", "Pump", "Compressor", "Valve") and the key attributes for each. Consider your `externalId` systems.
### 2. 2. Create or Import Assets
Use the `createAsset` API operation (or `bulkCreateAssets`) to populate your asset registry. Provide names, types, external IDs, parent IDs, locations, and other metadata for each facility, piece of equipment, well, etc.
\[!NOTE] Assets are assigned a unique, immutable SensorUp `assetId` upon creation.
### 3. 3. Build Hierarchies
Establish relationships: link equipment assets to their parent facility (e.g., a CPF), components to their parent equipment, and wells to their parent site or facility by setting the `parentId`.
### 4. 4. Manage Lifecycle & Status
As assets are commissioned, become active, undergo maintenance, or are decommissioned, update their `status`, `activeDate`, and `inactiveDate` using the `updateAsset` API operation.
### 5. 5. Define & Use Hierarchy Views (Optional)
For frequently accessed parts of your hierarchy (e.g., all equipment within a specific CGL), create `NamedHierarchyView`s to simplify querying and visualization.
### 6. 6. Link Observations to Assets
When ingesting sensor data or inspection results (Observations) into SensorUp Datastreams, use the `assetId` from Connected Assets as the primary identifier (FeatureOfInterest) to link that data to the correct facility, equipment, or well.
### 7. 7. Query & Analyze
Utilize API queries to retrieve asset information, explore hierarchical relationships (e.g., all components of a specific pump within a facility), and provide context for data from Connected Operations and Connected Markets.
## Role-Based Access Control
Asset management capabilities vary based on your assigned user role.
* **Viewer:** Can view all assets but cannot create, update, or delete any asset information.
* **Editor:** Can view all assets and manage their own assets (assets they created or are assigned to).
* **Administrator:** Full CRUD (Create, Read, Update, Delete) access to all assets including facilities, equipment, components, and wells.
* **Super Admin:** Complete access to all asset management features across all organizations.
> [!NOTE]
>
> For complete details on what each role can do across the platform, see the [User Roles and Permissions](/use-sensorup/user-management/User-roles-permissions) guide.
## Key Benefits of Connected Assets
* **Single Source of Truth:** A centralized registry for all your facilities, CGLs, CPFs, wells, equipment, and components.
* **Improved Data Context:** Hierarchies and rich metadata provide deep context for emissions and operational data.
* **Enhanced Analytics:** Consistent asset data enables more accurate and reliable analysis.
* **Streamlined Operations:** Easy access to asset information supports maintenance, inspection, and compliance workflows.
* **Foundation for Scalability:** A robust asset model supports the growth of your emissions management program.
## Next Steps
To effectively utilize Connected Assets:
> [card] [Assets Technical Model](/use-sensorup/assets/assets-model)
>
> Understand the complete asset data model and technical specifications.
> [card] [Connected Assets API Reference (GraphQL)](/api/graphql/subgraphs/assets)
>
> Detailed documentation for all GraphQL queries and mutations.
> [card] [CAM Assets Guide](/api/graphql/guides/cam-assets)
>
> Learn how to work with the Connected Asset Management API.
# Automatic Time-Bounding for Emission Events
Source: https://docs.sensorup.com/use-sensorup/emission-operations/emission-quantification/understanding-automatic-timebounding
Automatically establish emission event start and end times using non-detection survey data to get initial volume estimates faster.

## What is Automatic Time-Bounding?
Automatic time-bounding uses non-detection data from aerial surveys (like Insight M, Bridger) and OGI surveys to automatically establish preliminary start and end times for emission events. This eliminates manual data analysis and provides instant volume estimates for your reconciliation workflow.
> [card] 90-Day Lookback
>
> Searches up to 90 days for relevant non-detections
> [card] 125m Precision
>
> Uses spatial matching within 125 meters
> [card] Instant Estimates
>
> Get preliminary volumes immediately
## Why Use Automatic Time-Bounding?
> [card] The Problem
>
> **Without automatic time-bounding:**
>
> * Manual review of survey data takes hours per event
> * Initial volume estimates require extensive research
> * Delayed response times for high-priority events
> * Inconsistent duration assumptions across teams
> [card] The Solution
>
> **With automatic time-bounding:**
>
> * Instant preliminary duration and volume estimates
> * Leverages all available survey data automatically
> * Consistent, defensible methodology across events
> * Faster prioritization of follow-up actions
## How It Works
The system automatically analyzes your survey data to find the most relevant time boundaries for each emission event:
### 1. Finding Time Boundaries
* **Start Time**: Uses the closest non-detection that occurred before the emission was detected (within 90 days)
* **End Time**: Uses the closest non-detection that occurred after the emission was detected
### 2. Smart Data Matching
* **Spatial Proximity**: Non-detections must be within 125 meters of the emission location
* **Source Attribution**: Prioritizes matching by survey source when available
* **Survey Type Compatibility**: Follows business rules about which survey types can bound which events
### 3. Volume Calculation
* Combines the automatically determined duration with emission rate data
* Provides preliminary volume estimates for immediate use in reconciliation workflows
## Getting Started
> [!NOTE]
>
> **Ready to use automatic time-bounding?** This feature works when you have compatible non-detection survey data available for an emission event that doesn't yet have a duration set.
**1. Navigate to Emission Events**
Go to **Emission Events** in your dashboard and select the asset where you want to review an emission event.
**2. Select an Emission Event**
Choose an emission event that doesn't have a duration already set. Events with available non-detection data for time-bounding will show compatible observations.
**3. Review Available Non-Detects**
In the **Observations section** of the event blade, you'll see any compatible non-detects that can be used for automatic time-bounding. These appear when the system finds relevant survey data before or after your emission detection.
**4. Explore Non-Detect Details**
Click on any non-detect observation to open an additional blade with detailed information about the non-detect type, survey method, timing, and other relevant data that will be used for time-bounding.
## Survey Type Compatibility
Understanding which survey types can be used to bound different types of emission events:
> [card] Universal Bounding
>
> **These combinations work:**
>
> * Flyover to flyover event bounding
> * OGI to OGI event bounding
> * OGI to flyover event bounding
> [card] Restricted Bounding
>
> **This combination is restricted:**
>
> * Flyover to OGI event bounding is not allowed
> * This is because aerial surveys have higher detection thresholds than ground-based OGI cameras
## Common Use Cases
**Initial Event Assessment**
When a new emission event is detected, automatic time-bounding immediately provides a preliminary duration and volume estimate, helping you quickly assess the event's potential magnitude and prioritize your response.
**Reconciliation Workflow Support**
Use the automatically generated volume estimates as starting points in your reconciliation process, reducing the time needed to gather baseline information for regulatory reporting.
**Multi-Survey Data Integration**
Leverage all available survey data (both detections and non-detections) to create more defensible and accurate event timelines without manual cross-referencing.
## FAQ / Troubleshooting
> [accordion] What happens if no non-detection data is available?
>
> The system will use default time boundaries based on your configured settings. You can always manually override these with more precise information as it becomes available.
> [accordion] Can I override the automatically determined duration?
>
> Yes, you can easily override the automatic time boundaries with more precise information. The system preserves your manual adjustments and uses them for final volume calculations and reporting.
> [accordion] How accurate are the preliminary volume estimates?
>
> The estimates provide a defensible starting point based on available data, but they should be refined with additional information as your investigation progresses. They're designed for initial assessment and prioritization, not final reporting.
> [accordion] Why can't flyover non-detections bound OGI-detected events?
>
> Aerial surveys typically have higher minimum detection thresholds than ground-based OGI cameras. A flyover non-detection doesn't guarantee that a smaller emission detectable by OGI wasn't present.
> [accordion] What if multiple non-detections are available for the same time period?
>
> The system automatically selects the closest non-detection in time to the emission event, ensuring the most relevant temporal boundaries are used for duration calculation.
***
## Feedback & Support
> [!WARNING]
>
> **Found an issue with automatic time-bounding?** Contact support with the specific emission event ID and survey details for assistance with duration calculations.
Need to customize the survey type compatibility rules for your specific operations? Contact your Customer Success Representative to discuss advanced configuration options.
# Understanding the Time and Rate Engine
Source: https://docs.sensorup.com/use-sensorup/emission-operations/emission-quantification/understanding-time-and-rate-engine
Learn how the time and rate engine groups observations to calculate methane emission rates and temporal data for accurate volume quantification and reconciliation.
## What is the Time and Rate Engine?
The Time and Rate Engine is an intelligent calculation system that automatically processes your methane detection observations and transforms them into accurate emission events with calculated rates, volumes, and time boundaries. Instead of manually reconciling conflicting data from multiple sources, the engine applies consistent, industry-standard logic to give you reliable emission quantification for regulatory reporting and operational decision-making.
> [card] 90% Faster
>
> Automated calculation processing
> [card] Multi-Source
>
> Consolidates all observation types
> [card] Regulation-Ready
>
> Industry-compliant calculations
## Why Use the Time and Rate Engine?
> [card] The Problem
>
> **Without automated processing:**
>
> * Manual reconciliation of conflicting observation data
> * Inconsistent calculation methods across emission events
> * Time-consuming volume calculations and temporal boundary setting
> * Difficult to maintain audit trails for regulatory compliance
> [card] The Solution
>
> **With the Time and Rate Engine:**
>
> * Automatic consolidation using configurable priority rules
> * Consistent, traceable calculations across all emission events
> * Instant rate and volume calculations with confidence bounds
> * Complete audit trail for regulatory reporting
## How It Works
The Time and Rate Engine processes your emission observations through three core functions:
### 1. **Smart Data Consolidation**
When you have multiple observations for a single emission event, the engine automatically selects and combines the most reliable data using configurable priority rules. For example, it might use the spatial accuracy from a flyover survey combined with the temporal precision from a continuous monitoring system.
### 2. **Intelligent Rate & Volume Calculation**
The system calculates emission rates and volumes using industry-standard methods, handling different observation types appropriately:
* **Standard detections** (satellite, drone, optical gas imaging): Uses arithmetic mean for multiple observations
* **Time-based observations** (continuous monitoring, operational events): Combines volumes over duration for accurate rates
### 3. **Automatic Time Boundary Setting**
The engine establishes start and end times for emission events using the most reliable temporal data available, including:
* Confirmed times from observations with explicit timestamps
* Estimated times using no-detection data and inference rules
* Default estimation methods for events with unknown start times
## Common Use Cases
**Regulatory Reporting**: Automatically generate compliant emission calculations with complete audit trails for regulatory submissions, eliminating manual reconciliation work.
**Multi-Source Event Analysis**: Process emission events detected by multiple methods (satellite, flyover, ground surveys) into single, coherent records with the best available rate and temporal data.
**Operational Event Tracking**: Handle planned emissions like compressor blowdowns by combining operational data with sensor observations for accurate volume quantification.
## Getting Started
> [!NOTE]
>
> **Ready to use the Time and Rate Engine?** The system automatically processes observations as they're added to emission events. Here's how to work with the results.
**1. Review Grouped Observations**
Navigate to an emission event with multiple observations to see how the engine has consolidated your data sources.
**2. Understand the Calculations**
Review the calculated emission rate, volume, and time boundaries. The system shows which observations contributed to each calculation.
**3. Verify Results**
Check the confidence bounds and audit trail to ensure the calculations meet your accuracy requirements for reporting.
## Feature Specifications
> [accordion] Supported Observation Types
>
> **Site-Level Observations:**
>
> * Flyover Surveys (aircraft-based detection)
> * Drone Surveys (UAV-based detection)
> * Continuous Monitoring Systems (CMS)
> * Satellite Detection
>
> **Source-Level Observations:**
>
> * Venting, Flaring & Blowdown (VFB) events
> * Optical Gas Imaging (OGI)
> * Manual observations
> * Other monitoring systems
> [accordion] Calculation Methods
>
> **Rate Calculations:**
>
> * Single observation: Direct rate with confidence bounds
> * Multiple same-type: Arithmetic mean of all rates
> * Time-based observations: Volume-weighted rate calculation
>
> **Volume Calculations:**
>
> * Formula: Emission Rate × Duration (hours)
> * Automatic time zone conversion to UTC
> * Confidence bound propagation throughout calculations
> [accordion] Priority Configuration
>
> **Default Site-Level Priority:**
>
> 1. Flyover Surveys
> 2. Drone Surveys
> 3. Continuous Monitoring Systems
> 4. Satellite Detection
>
> **Default Source-Level Priority:**
>
> 1. Venting, Flaring & Blowdown
> 2. Optical Gas Imaging
> 3. Flyover Surveys
>
> *Note: Manual observations always receive highest priority regardless of type.*
## FAQ / Troubleshooting
> [accordion] Why are some time boundaries marked as 'Estimated'?
>
> Time boundaries are marked as "Estimated" when the system cannot find explicit start or end times in your observations. The engine uses no-detection data and default estimation rules (like 90-day lookback periods) to provide reasonable time boundaries for volume calculations.
> [accordion] How does the system handle conflicting observation data?
>
> The Time and Rate Engine uses configurable priority rules to select the most reliable data. Higher-priority observations (like manual entries) override lower-priority ones (like satellite detections). For observations of the same type, the system typically uses arithmetic averaging.
> [accordion] Can I override the automatic calculations?
>
> While the engine provides consistent baseline calculations, you can add manual observations with the highest priority to override automatic results when needed. The system maintains an audit trail showing both automatic and manual inputs.
> [accordion] What happens when an emission event is marked as repaired?
>
> When linked observations (like OGI leak repairs) are updated, the engine automatically recalculates the emission event's end time and volume to reflect the mitigation action, keeping your active emissions inventory current.
***
## Related Features
> [card] [Emission Event Management](/use-sensorup/emission-operations/event-management/getting-started-with-event-management)
>
> Learn how to create and manage emission events that feed into the Time and Rate Engine.
> [card] [Automatic Time Bounding](/use-sensorup/emission-operations/emission-quantification/understanding-automatic-timebounding)
>
> Understand how the system automatically sets temporal boundaries for emission events.
## Feedback & Support
> [!WARNING]
>
> **Found an issue with calculation results?** Report calculation discrepancies through the emission event interface, including the specific observations and expected vs. actual results.
# Attributing Emission Events
Source: https://docs.sensorup.com/use-sensorup/emission-operations/event-management/attributing-emission-events
Ensure accurate emissions reporting by manually attributing detected emission events to their correct source assets with hierarchical precision.

## What is Emission Event Attribution?
Emission Event Attribution allows you to ensure that detected methane emission events are correctly associated with their specific source assets. Whether you're correcting an automated assignment or refining attribution as more information becomes available, this feature helps maintain accurate emissions inventory data for regulatory compliance and operational insights.
> [card] Accurate Inventory
>
> Maintain precise emissions data
> [card] Quick Corrections
>
> Re-attribute in seconds
> [card] Audit Ready
>
> Full attribution history
## Why Use Emission Event Attribution?
> [card] The Problem
>
> **Without manual attribution:**
>
> * Automated systems may misattribute emissions to nearby assets
> * Complex facilities make precise source identification difficult
> * Missing context reduces data reliability for regulatory reporting
> * Difficult to track equipment-specific performance trends
> [card] The Solution
>
> **With Attribution:**
>
> * Manually correct misaligned emissions to ensure inventory accuracy
> * Select specific equipment within asset hierarchies for pinpoint precision
> * Add explanatory context and categorize by regulatory standards (OGMP 2.0)
> * Enable deeper insights through properly categorized emission data
## Getting Started
> [!NOTE]
>
> **Ready to attribute emission events?** Follow these steps to correct emission source assignments. The process takes just a few minutes and immediately updates your emissions data.
**1. Open Attribution Modal**
Navigate to an emission event in your dashboard and click the "Attribution" button to open the source attribution interface.
**2. Select Source Asset**
Choose the correct source asset from the proximity-ordered dropdown list. You can select from top-level assets or drill down to specific equipment within the hierarchy.
**3. Add Context and Save**
Select the appropriate Source Category for OGMP 2.0 compliance, add an explanation for the attribution change, and save your updates.
## Common Use Cases
### Correcting Automated Misattributions
When reviewing daily emissions reports, you notice an observation assigned to the wrong asset. Use the attribution feature to reassign it to the correct source, ensuring your emissions inventory remains accurate and trustworthy.
### Refining Equipment-Level Attribution
An automated alert identifies an emission near a complex facility. Drill down through the asset hierarchy (Site → Facility → Equipment) to pinpoint the exact source, enabling you to dispatch the correct maintenance team and track component-level reliability.
### Preparing for Regulatory Audits
Before regulatory reviews, ensure all emissions are properly attributed with clear justifications. Add explanatory context for manual changes to demonstrate a compliant and transparent emissions management process.
## FAQ / Troubleshooting
> [accordion] What happens when I change an emission's attribution to a different asset?
>
> When you attribute an emission to an asset outside its current hierarchy, the system automatically recalculates timing data and updates the event status. You'll be navigated to the new asset's context to confirm the changes.
> [accordion] Can I see the history of attribution changes?
>
> Yes, each emission event maintains a complete audit trail of all attribution changes. This history includes who made the change, when it occurred, and the reasoning provided for the modification.
> [accordion] What are Source Categories and why do I need them?
>
> Source Categories align your emissions data with OGMP 2.0 regulatory reporting standards. Selecting the appropriate category ensures your data meets compliance requirements and enables standardized industry reporting.
> [accordion] Why can't I see certain assets in the attribution list?
>
> The asset list is filtered by proximity to the emission coordinates and limited to assets within your organization's scope. Assets are ordered by distance from the emission point to help you quickly identify the most likely sources.
## Best Practices
### Attribution Guidelines
* **Review proximity suggestions first**: Assets are ordered by distance from the emission point - the closest options are often the most likely sources
* **Use specific equipment when possible**: Attribution to specific equipment rather than high-level facilities provides more actionable insights
* **Always provide explanations**: Document your reasoning for attribution changes to support audit trails and team understanding
* **Verify updates immediately**: Check that the data table reflects your attribution changes to confirm successful updates
### Regulatory Compliance
* **Select appropriate Source Categories**: Ensure OGMP 2.0 compliance by choosing the correct emission source category
* **Maintain audit trails**: Always include explanatory context for manual attribution changes
* **Regular reviews**: Periodically review attributed emissions to ensure ongoing data accuracy
***
## Related Features
> [card] [Emission Event Management](/use-sensorup/emission-operations/event-management)
>
> Learn how to manage the complete lifecycle of emission events
> [card] [Insights & Analytics](/use-sensorup/emission-operations/insights-and-analytics)
>
> Analyze your properly attributed emissions data for operational insights
## Feedback & Support
> [!WARNING]
>
> **Found an issue with attribution?** If you encounter problems with asset selection, attribution saving, or unexpected behavior, contact our support team with the specific emission event details.
# Audit History
Source: https://docs.sensorup.com/use-sensorup/emission-operations/event-management/auditing-changes-for-events
Complete audit trails for emission observations and events with full transparency and compliance tracking

## What is Audit History?
Audit History provides a complete, chronological record of every change made to your emission observations and events throughout their entire lifecycle. This powerful feature enables full data integrity, compliance reporting, and transparent tracking of all modifications—whether made by your team or automated systems.
> [card] Complete Transparency
>
> Every field change tracked
> [card] Compliance Ready
>
> Full audit trail for reporting
> [card] User Attribution
>
> Know who changed what and when
## Understanding the Two History Tabs
The audit history feature tracks changes to two distinct types of records, each serving a different purpose in your emissions management workflow:
> [card] Observation History
>
> **The Data Integration Log**
>
> Tracks changes to raw detection data, typically from third-party systems (like Continuous Monitoring Systems). This is mostly read-only and system-driven.
>
> **Key Question:** "Where did this data come from, and has the source changed it?"
> [card] Emission Event History
>
> **The User Action Log**
>
> Tracks all actions your team takes on emission events—attribution changes, status updates, closures, and investigation activities.
>
> **Key Question:** "What has our team done with this event?"
### Visual Examples
The audit history interface provides different views to help you focus on the information you need:
**All Events History**
View the complete audit trail combining both observation and emission event changes in a unified timeline.

**Emission Event Only History**
Filter to see only the changes made to the emission event itself—perfect for tracking team actions and decisions.

**Observation Only History**
Filter to see only the changes made to underlying observations—ideal for verifying data source updates.

## Why Use Audit History?
> [card] The Problem
>
> **Without audit history:**
>
> Can't verify data changes for compliance audits
>
> Can't track who made attribution or status changes
>
> Lost context when investigating events
>
> Manual timeline reconstruction is time-consuming
> [card] The Solution
>
> **With Audit History:**
>
> Automatic, unchangeable audit trail
>
> Complete visibility into who changed what and when
>
> Regulatory-ready compliance documentation
>
> Instant access to complete event lifecycle
## Common Use Cases
**Compliance Reporting**
Track all modifications to emission data for regulatory reporting. View the complete history of any observation or event to demonstrate data integrity and proper handling procedures to auditors, with automatic documentation of every change made by your team or integrated systems.
**Event Investigation**
Understand how an emission event evolved from detection to resolution. See which team members attributed the event, requested inspections, and ultimately closed it out, providing full context for every decision and action taken throughout the event lifecycle.
**Data Source Verification**
Identify patterns in how continuous monitoring systems refine their data over time. Analyze how emission rates or attributions change as more information becomes available, helping you understand data quality and system behavior.
**Attribution Tracking**
When event attribution changes, review the complete history to see who made the change, when it occurred, and what the previous attribution was. This helps you understand the investigation process and verify that attribution decisions were made correctly.
**Work Order Prevention**
Before dispatching field teams, check the audit history to see if an inspection has already been requested or if work orders have been created. This prevents duplicate work and helps you coordinate field operations more efficiently.
## Getting Started
> [!NOTE]
>
> **Ready to use Audit History?** The feature is automatically enabled for all emission observations and events. Follow these steps to access the complete history.
**1. Navigate to an Emission Event or Observation**
Open any emission event or observation detail page from your emissions dashboard.
**2. Locate the History Tab**
Look for the **"History"** tab in the detail view. This tab appears alongside other information tabs.
**3. Review the Audit Trail**
The history displays in chronological order (newest first) showing:
* **What changed**: Field name and values (before/after)
* **When**: Exact timestamp of the change
* **Who**: User who made the change (or "System" for automated updates)
* **Change type**: Creation, update, status change, attribution, etc.
## Understanding Observation History
Observations are raw detection data, typically sent from third-party systems like Continuous Monitoring Systems (CMS) or occasionally created manually.
### What You'll See
> [accordion] System-Driven Updates
>
> Most observations are **not editable** by users. Their history shows changes made by the **"System"** as external data sources (like CMS platforms) refine their data. You may see updates every 15-30 minutes for active monitoring systems as they:
>
> * Refine emission rate calculations
> * Update detection confidence levels
> * Adjust attribution as more data becomes available
> * Add additional metadata from processing pipelines
> [accordion] Field Changes Tracked
>
> The system tracks changes to all observation fields including:
>
> * **Emission Rate**: Value and unit (kg/hr, etc.)
> * **Detection Time**: Start and end times
> * **Attribution**: Asset and equipment references
> * **Status**: Detection status changes
> * **Additional Data**: Confidence intervals, processing metadata
> * **Media**: Links to images or videos
> [accordion] Read-Only Protection
>
> Observations integrated from external systems are typically read-only to protect data integrity. The history log helps you understand:
>
> * Why an observation appears "locked"
> * That the data source controls the record
> * How the source system has refined the data over time
### Key Use Cases for Observation History
> [card] Compliance Verification
>
> **When:** Auditing a compliance report
>
> **Goal:** Verify the source of detection data and prove its integrity
>
> **Action:** Review the complete, unchangeable audit trail showing system-generated updates
> [card] Data Investigation
>
> **When:** CMS data looks different today
>
> **Goal:** Understand what changed and when the system updated it
>
> **Action:** Find the specific field changes (e.g., emission rate) and their timestamps
> [card] Integration Troubleshooting
>
> **When:** Questioning data integration
>
> **Goal:** Validate that the integration is working correctly
>
> **Action:** Confirm the observation was created by "system" and review original data
> [card] Source Refinement Analysis
>
> **When:** Monitoring active CMS detections
>
> **Goal:** See if emission rates or attribution are still being updated or have stabilized
>
> **Action:** Check recent history entries for continued system updates
## Understanding Emission Event History
Emission events summarize one or more observations into a single, actionable incident that your team manages, investigates, and resolves.
### What You'll See
> [accordion] Detailed Change Logging
>
> The event history is highly detailed. A single user action (like "Close Event") may result in multiple fields changing at once:
>
> * `status` → "CLOSED"
> * `closedBy` → User ID
> * `closureDate` → Timestamp
> * `statusReasons` → Closure justification
>
> The history log shows **one row for every single field** that changes, giving you a granular and complete record.
> [accordion] User Actions Tracked
>
> All team actions are logged including:
>
> * **Attribution changes**: Moving events between assets or equipment
> * **Status updates**: Opening, closing, false alarming events
> * **Observation grouping**: Adding or removing observations
> * **Follow-up requests**: Requesting OGI inspections or repairs
> * **Field updates**: Changing dates, rates, or other properties
> * **Notes and documentation**: Adding investigation details
> [accordion] Complete Event Lifecycle
>
> Track the full journey from detection to resolution:
>
> 1. **Creation**: When the event was first detected (usually by system)
> 2. **Investigation**: Attribution refinements, observation additions
> 3. **Action**: Work orders, inspection requests
> 4. **Resolution**: Closure, false alarm designation, or ongoing monitoring
### Key Use Cases for Emission Event History
> [card] Active Event Management
>
> **When:** Reviewing an active emission
>
> **Goal:** Get a complete picture of how the event has been handled
>
> **Action:** View the log of every action from creation to present
> [card] Attribution Tracking
>
> **When:** Event attribution has changed
>
> **Goal:** Understand who changed it and when (e.g., from 'Facility A' to 'Pipeline B')
>
> **Action:** Find the attribution change in history with user and timestamp
> [card] Closure Verification
>
> **When:** Auditing a closed event
>
> **Goal:** Verify closure timestamp and user for compliance
>
> **Action:** Review the status change entry showing who marked it closed and when
> [card] Work Order Prevention
>
> **When:** Need to dispatch a field team
>
> **Goal:** See if an inspection has already been requested
>
> **Action:** Check history for work item creation to avoid duplicate work
## FAQ / Troubleshooting
> [accordion] Why does the history show 'System' as the user?
>
> The "System" user appears when changes are made automatically by integrated data sources (like Continuous Monitoring Systems) or internal automated processes. This ensures you can distinguish between human actions and automated system updates.
> [accordion] Why can't I edit some fields shown in the history?
>
> Observations from integrated sources are typically read-only to preserve data integrity. The history shows you changes made by the source system. If you need to modify data, you'll typically work with the emission event rather than the underlying observation.
> [accordion] Why do I see multiple rows for a single action?
>
> When you perform an action like "Close Event," multiple fields may change simultaneously (status, closed\_by, closure\_date). The history displays one row per field change for complete granularity. This helps auditors see exactly what data changed.
> [accordion] Can I export the audit history?
>
> Yes, you can export the complete audit history for compliance reporting. Contact your system administrator for export options, or use the GraphQL API to programmatically retrieve audit data.
> [accordion] How far back does the history go?
>
> The audit history captures all changes from the moment the feature was enabled in your environment. For observations and events created before the feature launch, history tracking begins from that enablement date forward.
> [accordion] What if I need to prove data integrity for an audit?
>
> The audit history is stored in an immutable event store, meaning changes cannot be deleted or modified after they're recorded. This provides legally defensible proof of data integrity for regulatory audits.
## Best Practices
> [card] Do This
>
> **Review history regularly** during investigations to understand the full context of an emission event
>
> **Use history for training** to help new team members understand proper workflows and procedures
>
> **Reference specific history entries** when communicating with regulators or auditors
>
> **Check observation history** before questioning data quality—the source may have refined it
> [card] Not That
>
> **Don't assume one history row = one action**—single actions may change multiple fields
>
> **Don't try to edit history**—it's intentionally immutable for compliance
>
> **Don't ignore system updates**—they provide valuable insight into data refinement
>
> **Don't skip history review**—it contains critical context for decision-making
## Related Features
> [card] [Emission Event Management](/use-sensorup/emission-operations/event-management/getting-started-with-event-management)
>
> Learn how to manage emission events from detection to resolution
> [card] [Attribution](/use-sensorup/emission-operations/event-management/attributing-emission-events)
>
> Understand how to attribute emissions to specific assets and equipment
> [card] [Event Statuses](/use-sensorup/emission-operations/event-management/emission-event-statuses-v2)
>
> Learn about different emission event statuses and lifecycle stages
> [card] [Follow-up Requests](/use-sensorup/emission-operations/event-management/overview-of-follow-up-requests)
>
> Create and track inspection requests and work orders
***
## Feedback & Support
> [!WARNING]
>
> **Found a bug or issue with Audit History?** Contact your system administrator or SensorUp support team for assistance.
**Have questions or suggestions?** Share your feedback to help us improve the audit history feature.
# Using Emission Event Statuses for Workflow
Source: https://docs.sensorup.com/use-sensorup/emission-operations/event-management/emission-event-statuses-v2
Efficiently manage your emission workflow with smart status tracking that automatically prioritizes work and ensures nothing falls through the cracks.

## What are Emission Event Statuses?
Emission Event Statuses help you efficiently manage your emission workflow by automatically organizing events into four clear categories. Instead of manually tracking which emissions need attention, the system provides instant visibility into what requires action versus what's already handled, allowing you to focus your team's efforts where they matter most.
> [card] Instant Prioritization
>
> See critical events requiring immediate action within seconds of logging in
> [card] Zero Missed Events
>
> Automated status tracking ensures no emission falls through the cracks
> [card] Smart Workflow
>
> System intelligently moves events through your workflow without manual effort
## Why Use Emission Event Statuses?
> [card] The Problem
>
> **Without status management:**
>
> * Time wasted sorting through resolved events
> * Critical emissions missed in cluttered lists
> * Manual tracking prone to human error
> * No clear workflow for field teams
> * Compliance gaps from poor organization
> [card] The Solution
>
> **With Emission Event Statuses:**
>
> * Instant visibility into priority work
> * Automated workflow reduces manual tasks
> * Clear action items for every team member
> * Compliance-ready audit trails
> * Efficient resource allocation
## Understanding the Four Status Types
The system organizes every emission event into one of four statuses, each with a clear meaning and required action:
> [card] 🟢 Open
>
> **Default status for new events**
>
> **What it means:** This emission needs immediate attention and action.
>
> **Your action:** Prioritize these events for investigation and field response. These are your highest priority items.
> [card] 🟡 In Progress
>
> **Work has started**
>
> **What it means:** Someone is actively working on this emission, but it's not fully resolved yet.
>
> **Your action:** Continue working through required tasks or monitor progress if assigned to another team member.
> [card] 🔵 Closed
>
> **Fully resolved**
>
> **What it means:** The emission has been completely addressed and all required actions are finished.
>
> **Your action:** Use these events for reporting and compliance documentation.
> [card] ⚪ False Alarm
>
> **Not a real emission**
>
> **What it means:** Investigation determined this was a false positive detection.
>
> **Your action:** Filter these out of your active work queue - no further action needed.
## Getting Started
> [!NOTE]
>
> **Ready to streamline your emission workflow?** Follow these quick steps to start using status-based prioritization immediately.
**1. Access Your Emission Events**
Log into SensorUp and navigate to the Emission Events page. You'll see all events with their current status displayed.
**2. Filter by Priority**
Click the status filter and select "Open" to see only events requiring immediate action. This gives you a clean, prioritized work list.
**3. Take Action**
Start with the first Open event. The system will automatically move it to "In Progress" when you begin working, and to "Closed" when complete.
## How Status Changes Work
### Automatic Updates
The system intelligently updates statuses based on data completeness, field actions, and verification results. Understanding these rules helps you predict when events will change status automatically.
#### Events Stay OPEN When Missing Critical Information
The system keeps events in **Open** status until all required data is available:
> [accordion] Missing End Time
>
> **What this means**: The emission appears ongoing - system hasn't confirmed it stopped
>
> **Why it stays Open**: Without an end time, we can't determine if the emission is resolved
>
> **How to resolve**: Field verification to confirm emission has ceased, or system detection of emission end
> [accordion] Missing Start Time
>
> **What this means**: System can't determine when the emission began
>
> **Why it stays Open**: Timeline is incomplete for proper assessment
>
> **How to resolve**: Field investigation to establish when emission likely started
> [accordion] Active Monitoring Alarms
>
> **What this means**: Continuous monitoring system triggered an alarm needing investigation
>
> **Why it stays Open**: Alarm indicates ongoing issue requiring attention
>
> **How to resolve**: Investigate monitoring alert and address underlying cause
> [accordion] Active Work Orders
>
> **What this means**: Field crew has an active work order for this emission
>
> **Why it stays Open**: Work is in progress but not yet complete
>
> **How to resolve**: Complete field work and mark work order as finished
#### Automatic Status Transitions
> [card] Open → In Progress
>
> **Triggers automatically when:**
>
> * Work order is created and assigned to field crew
> * Team member takes first action on the event
> * Investigation or repair work begins
> [card] In Progress → Closed
>
> **Triggers automatically when:**
>
> * All required data is collected (start/end times)
> * No active monitoring alarms remain
> * Field crew marks work as complete
#### Auto-Close Conditions
Events automatically move to **Closed** status when these conditions are met:
* ✅ **Complete Timeline**: Both start and end times are established
* ✅ **No Active Alarms**: All monitoring systems show normal operation
* ✅ **Work Complete**: No active work orders or field tasks remain
* ✅ **Verification Confirmed**: Camera inspection or survey confirms resolution
### Manual Controls
You maintain full control and can override the system when needed:
> [accordion] When to Manually Close Events
>
> Use manual closure when an emission is resolved through means the system doesn't automatically track, such as:
>
> * Field crew confirms repair completion outside the system
> * Equipment replacement resolves the underlying issue
> * Operational changes eliminate the emission source
> [accordion] Marking False Alarms
>
> Mark events as False Alarm when investigation reveals:
>
> * Satellite or drone detected something other than methane
> * Weather conditions caused false readings
> * Equipment reflection or interference created false positive
> * No physical emission source can be identified
> [accordion] Reopening Closed Events
>
> Reopen events when:
>
> * An emission reappears after initial repair
> * Additional investigation reveals the issue wasn't fully resolved
> * New detection data suggests the event is still active
### Bulk actions
You can update multiple emission events at once using bulk actions:
**1. Select events**
Select rows in the emissions table by clicking on them. To select multiple rows quickly, click on a row, hold Shift, and click on another row further down to select all rows in between.
**2. Choose an action**
At the bottom of the page, select **False Alarm** or **Close**.
**3. Add explanation and confirm**
Add an Explanation for the action and click **Confirm**. A success message will display to confirm the action was successful.
> [!TIP]
>
> To undo a bulk action, click on the event and use the **Undo False Alarm** or **Undo Close** button at the top of the blade.
## Common Use Cases
### Daily Priority Management
**Scenario**: You're a field operations manager starting your day and need to assign work to your team.
**Workflow**: Filter events by "Open" status to see all unresolved emissions. Assign based on location and severity, knowing the system will track progress automatically.
**Result**: Your team works efficiently on real priorities without time wasted on already-handled events.
### Compliance Reporting
**Scenario**: You need to prepare monthly emission reports for regulatory compliance.
**Workflow**: Filter by "Closed" status for the reporting period. The system provides complete audit trails showing detection, response, and resolution for each event.
**Result**: Fast, accurate compliance reporting with documented evidence of proper emission management.
### False Alarm Management
**Scenario**: Field investigation reveals a satellite detection was actually equipment reflection, not a real emission.
**Workflow**: Mark the event as "False Alarm" with investigation notes. The system removes it from active work queues while preserving the record.
**Result**: Clean work lists focused on real emissions, with historical record maintained for analysis.
## Special Facility Considerations
> [!WARNING]
>
> **Enhanced Verification Required**: Certain facility types have additional verification requirements that affect status behavior.
Some facilities require enhanced verification protocols:
* **Extended Open Periods**: Events may stay "Open" longer than at standard facilities
* **Manual Verification Required**: Even when automated systems show no issues, events need human confirmation
* **Enhanced Accuracy**: Stricter verification standards ensure proper oversight of critical operations
**This is intentional behavior** - high-priority facilities require extra caution to ensure nothing important is missed.
## FAQ / Troubleshooting
> [accordion] Why do some events stay Open longer than others?
>
> Several factors can keep events in Open status:
>
> * Missing start/end time data requiring field verification
> * Cannot identify specific equipment source (need more precise location)
> * Continuous monitor alarm needs investigation
> * High-priority facility requiring enhanced verification
> [accordion] How do I know what action to take on an Open event?
>
> Open events typically need one of these actions:
>
> * Dispatch field crew for investigation
> * Review monitoring alarms for additional data
> * Check if emission source can be more precisely identified
> * Coordinate with operations for equipment status
> [accordion] Can I change a status back if I made a mistake?
>
> Yes, you can reverse most status changes:
>
> * Reopen Closed events if the emission returns
> * Undo False Alarm if investigation was incorrect
> * Manually close In Progress events if resolution happens outside the system
> [accordion] What if my event doesn't fit the standard workflow?
>
> Use manual status controls for exceptional situations:
>
> * Skip automatic progressions when appropriate
> * Add detailed notes explaining the unique circumstances
> * Coordinate with your team lead for non-standard cases
***
## Related Features
> [card] [Emission Event Model](/use-sensorup/emission-operations/technical-specifications/emission-event-model)
>
> Understand the complete data structure behind emission events and how information flows through the system.
> [card] [Event Management Workflow](/use-sensorup/emission-operations/event-management/getting-started-with-event-management)
>
> Learn the complete workflow for managing emission events from detection through resolution.
## Feedback & Support
> [!WARNING]
>
> **Found an issue with status tracking?** Contact support immediately to ensure proper emission management and compliance.
**Having trouble with workflow efficiency?** Share your feedback to help us improve status automation and prioritization features.
# Getting Started with Root Cause Analysis
Source: https://docs.sensorup.com/use-sensorup/emission-operations/event-management/getting-started-root-cause-analysis
Learn how to perform systematic root cause analysis for emission events to identify and address underlying issues.

## Welcome to Root Cause Analysis
When an emission is detected on your assets, determining its root cause is critical for effective environmental management and regulatory compliance. This guide will walk you through the systematic process of investigating emission events to identify their underlying causes and determine the most appropriate follow-up actions.
> [!NOTE]
>
> **Time Required:** 15-20 minutes for your first analysis
> **What You'll Learn:**
>
> * How to navigate and use the asset-level emission analysis interface
> * How to correlate spatial, temporal, and operational data for investigations
> * How to prioritize and take action on emission events
> [!WARNING]
>
> **Common Pitfalls:**
>
> * Starting analysis without understanding the full temporal context - always review the timeline first
> * Focusing only on large emissions and missing patterns in smaller, recurring events
## Your First Root Cause Analysis
**1. Access Your Asset's Emission Events**
Navigate to the emission events section and select the specific asset you want to investigate. The system will present you with three integrated views: a map showing spatial relationships, a timeline displaying temporal patterns, and a detailed table of events.
Look for the emission events represented as dots on the map - larger dots indicate higher emission volumes that may require immediate attention.
**2. Assess the Spatial and Temporal Context**
Begin your investigation by examining both when and where events occurred:
* **Review the Timeline**: Look for concurrent events that might be related. Events occurring close together in time could indicate a common cause.
* **Examine the Map**: Check if multiple detections appear in the same location, which could suggest a persistent leak or recurring operational issue.
* **Check Event Patterns**: Use the timeline to identify if emissions coincide with operational activities or appear randomly.
The system automatically shows emission plume imagery when available, helping you understand wind direction and potential emission travel paths.
**3. Investigate with Operational Context**
Click on any emission event from the map, timeline, or table to open detailed information. The system provides integrated operational data ("Clues") that include:
* Maintenance notifications and work orders
* Venting, flaring, and blowdown logs
* Equipment operational status
* Nearby asset activity (including assets you don't own)
This operational context helps you determine if emissions were from planned events or unexpected leaks.
**4. Focus Your Analysis**
Use the filtering capabilities to narrow down your investigation:
* **Geographic Focus**: Zoom in on the map to automatically filter the timeline and table to specific areas
* **Time Period Focus**: Zoom in on the timeline for a more granular view of events that occurred close together
* **Event Type Filtering**: Filter by detection type (continuous monitoring, flyover surveys, etc.) to understand how different systems are observing the same emissions
This focused approach helps you identify patterns and correlations more effectively.
**5. Determine Root Cause and Take Action**
After analyzing the spatial, temporal, and operational context, determine the most likely root cause and execute appropriate follow-up actions:
* **For Equipment Issues**: Group related events and request an optical gas imaging (OGI) inspection
* **For Operational Events**: Verify if emissions were from planned activities like maintenance or venting
* **For False Alarms**: Mark events appropriately and check for nearby assets that might be the actual source
* **For Patterns**: Create work orders for recurring issues or schedule preventive maintenance
> [!TIP]
>
> **Analysis Complete!**
>
> ✅ You've reviewed spatial and temporal relationships
>
> ✅ You've examined operational context and clues
>
> ✅ You've identified the most likely root cause
>
> ✅ You've initiated appropriate follow-up actions
## Quick Analysis Tips
> [card] Prioritize by Impact
>
> **Focus on:** Large emission volumes and persistent patterns
> **Time:** 2-3 minutes to identify high-priority events
> [card] Look for Correlations
>
> **Focus on:** Events occurring at the same time or location
> **Time:** 3-5 minutes to identify related events
> [card] Check Operational Context
>
> **Focus on:** Maintenance windows and operational activities
> **Time:** 5-7 minutes to correlate with work orders
> [card] Verify with Multiple Detection Types
>
> **Focus on:** Comparing continuous monitoring with survey data
> **Time:** 3-5 minutes to cross-validate detections
## If You Get Stuck
> [accordion] I see many events but can't identify patterns
>
> Start with the largest events first - these often have the clearest operational context. Use the magnitude filtering to focus on significant emissions, then gradually expand your analysis to smaller events once you understand the major patterns.
> [accordion] The timeline shows concurrent events but I'm not sure if they're related
>
> Look at both the spatial proximity on the map and the operational context. Events that occur at the same time AND in nearby locations are likely related. Check if there was maintenance or operational activity during that time period using the integrated clues data.
> [accordion] I'm seeing emissions attributed to my asset but suspect they're from elsewhere
>
> Use the map to examine nearby assets and their activity. The system shows operational context for surrounding assets to help you determine if emissions were incorrectly attributed. Look for wind direction in the plume imagery to trace potential sources.
> [accordion] Multiple detection types show different information for the same event
>
> This is normal - different detection methods (continuous monitoring vs. aerial surveys) have different capabilities and timing. Use the timeline to understand the sequence of detections and focus on the most reliable data source for your specific situation.
## What's Next?
Once you're comfortable with basic root cause analysis, explore these advanced capabilities:
> [card] [Event Grouping & Management](/use-sensorup/emission-operations/event-management)
>
> Learn how to group related emission events and manage them through their complete lifecycle from detection to resolution.
> [card] [Advanced Analytics & Insights](/use-sensorup/emission-operations/insights-and-analytics)
>
> Discover how to use trend analysis and summary insights to identify long-term patterns and optimize your emission management strategy.
***
## Feedback & Support
> [!WARNING]
>
> **Found an issue with root cause analysis tools?** Contact your system administrator or use the feedback option in the platform to report problems with data accuracy or system functionality.
# Managing Methane Events from Detection to Resolution
Source: https://docs.sensorup.com/use-sensorup/emission-operations/event-management/getting-started-with-event-management
Transform how you handle emission incidents by creating a complete, defensible workflow from initial detection through final compliance reporting.
## The Scenario
Your facility receives an automated methane detection alert from a satellite flyover. Within minutes, you need to determine if this represents a genuine leak requiring immediate field response, a known operational activity, or a false positive. The stakes are high: genuine leaks need rapid repair to minimize environmental impact and regulatory exposure, while false alarms waste valuable field resources. Meanwhile, regulators expect complete documentation showing exactly what happened, when it occurred, which equipment was involved, and how it was resolved.
Traditional approaches leave you juggling multiple systems—checking operational logs in one place, dispatching field crews through another, and manually piecing together compliance reports from scattered data sources. This fragmented process leads to delayed responses, incomplete documentation, and difficulty defending your emissions data during audits.
> [!NOTE]
>
> **Who This Applies To:** Facility managers, environmental compliance officers, operations supervisors, and field coordinators responsible for methane leak management
> **Common Triggers:** Automated satellite detections, continuous monitoring alarms, drone survey alerts, or manual reports of suspected emissions
## What You'll Accomplish
> [card] Primary Goal
>
> Create a complete, defensible emission event record from initial detection through final resolution with full audit trail and compliance documentation
> [card] Success Metrics
>
> Reduce investigation time by 60%, eliminate double-counting in compliance reports, and achieve 100% audit-ready documentation for all emission incidents
## Workflow Overview
```mermaid theme={null}
flowchart TD
A[Methane Detection Alert] --> B{Triage: Real Leak?}
B -->|Unknown| C[Create Follow-up Request]
B -->|Yes| D[Verify Asset Attribution]
B -->|No| E[Mark False Alarm]
C --> F[Field Investigation]
F --> G{Investigation Results}
G -->|Confirmed Leak| D
G -->|No Leak Found| E
G -->|Operational Activity| H[Add Manual Observation]
D --> I[Group Related Detections]
I --> J[Create Repair Work Order]
J --> K[Track Resolution Progress]
K --> L[Verify Repair Completion]
L --> M[Generate Compliance Report]
H --> N[Document Operational Context]
N --> O[Close with Explanation]
E --> P[Update Records]
style A fill:#ff6b6b
style M fill:#51cf66
style O fill:#51cf66
style P fill:#51cf66
```
## Step-by-Step Walkthrough
**1. Receive and Assess the Initial Detection**
When an automated methane detection alert arrives, immediately access the Emission Events dashboard and filter for "Open" status events. The newest detection appears at the top with preliminary information including location, time, and detection source.
**Key Assessment Questions:**
* Is this at a location with recent operational activity?
* Are there multiple detections that might represent the same leak?
* Does the timing align with scheduled maintenance or operations?
**2. Initiate Quick Triage Through Follow-up Requests**
If the detection's nature is unclear, create an "Ops Comment" follow-up request to quickly determine if this represents a known operational activity or requires leak investigation.
**Action Steps:**
* Click the emission event to open the detail panel
* Select "Ops Comment" from the follow-up actions
* Add specific questions: "Was there planned venting at Tank 403 between 2-4 PM yesterday?"
* Include relevant operators and supervisors as email recipients
* Submit to create a trackable work item with automatic notifications
This typically resolves within 2-4 hours, preventing unnecessary field dispatches for planned activities.
**3. Correct Asset Attribution for Accurate Tracking**
Verify the emission is attributed to the correct facility and specific equipment. Accurate attribution ensures field crews go to the right location and compliance reports reflect the true emission source.
**Attribution Process:**
* Review current attribution in the event detail panel
* Click "Attribution" if correction is needed
* Select the correct source asset from the proximity-ordered list
* Choose appropriate Source Category (OGMP 2.0 compliance)
* Add explanation: "Corrected from Separator 12 to adjacent Compressor 5A based on wind patterns"
* Save changes to update timing calculations automatically
**4. Group Related Observations to Prevent Double-Counting**
If multiple detection sources (satellite, drone, continuous monitoring) have identified the same leak, group them into a single emission event to prevent inflated volume calculations.
**Grouping Decisions:**
* Review the "Group Observations" option in the event panel
* Select "Add Existing" to find related events within the 90-day window
* Choose detections that clearly represent the same physical emission source
* Consider timing, location, and asset attribution when deciding
* Confirm grouping to create consolidated volume calculations
**Example:** Satellite detection at 9:00 AM, drone confirmation at 11:30 AM, and continuous monitor alarm from 8:45 AM all represent one leak—group them together.
**5. Create Field Investigation Work Orders**
For confirmed or suspected leaks, initiate formal field investigation through structured follow-up requests that create trackable work orders.
**Investigation Options:**
* **Field Inspection**: General investigation for uncertain cases
* **OGI Request**: Optical gas imaging for visual confirmation
* **Data Collection**: Structured forms for detailed equipment information
Include priority level, specific investigation requirements, and all relevant context. The system creates work orders, sends notifications, and updates the event status to "In Progress."
**6. Document Operational Context with Manual Observations**
When field investigation reveals a planned operational activity (like a compressor blowdown), add a manual observation to provide complete context and more accurate volume calculations.
**Documentation Process:**
* Click "Add Observation" or access the "CreateNew" tab
* Enter precise operational timing from maintenance logs
* Input actual emission rates from equipment specifications
* Add detailed description: "Scheduled compressor blowdown for valve maintenance - Compressor 5A"
* Upload supporting documentation (work orders, maintenance logs)
* Submit to integrate with the detection data
This creates defendable audit trails and improves volume accuracy for compliance reporting.
**7. Track Progress and Verify Completion**
Monitor work order progress through the event status system. Events automatically progress from "Open" to "In Progress" when work orders are created, and move to "Closed" when all resolution criteria are met.
**Verification Checkpoints:**
* Confirm field crew completion reports
* Verify follow-up surveys show no ongoing emission
* Ensure all required documentation is attached
* Review final volume calculations for accuracy
Events that don't auto-close indicate missing information or ongoing work requiring attention.
## Role-Based Access Control
Emission event management capabilities vary based on your assigned user role:
* **Viewer**: Can view emission events but cannot create, update, or manage them
* **Editor**: Can create and update emission events, create follow-up requests, and manage event attribution
* **Administrator**: Full create and update access to emission events and all related workflows
* **Super Admin**: Complete access to all emission operations features
> [!NOTE]
>
> Learn more about user roles and what each can do in the [User Roles and Permissions](/use-sensorup/user-management/User-roles-permissions) guide.
## Key Considerations
> [accordion] Essential Prerequisites
>
> **Permissions Required:**
>
> * Emission event management access
> * Work item creation rights
> * Asset attribution permissions for your facilities
> * Follow-up request creation capability
>
> **System Dependencies:**
>
> * Integration with field management systems for work orders
> * Email notifications for follow-up requests
> * Asset database with current facility and equipment information
> * Continuous monitoring integration (if applicable)
> [accordion] Regulatory and Compliance Factors
>
> **Regulatory Requirements:**
>
> * OGMP 2.0 source category classification for all attributions
> * Complete audit trail documentation for all manual actions
> * Accurate time boundaries for emission duration calculations
> * Supporting documentation for operational vs. fugitive classifications
>
> **Compliance Timing:**
>
> * Initial response within regulatory reporting timeframes
> * Field investigation scheduling based on leak severity
> * Documentation completion before quarterly reporting periods
> * Audit trail preservation for regulatory inspection readiness
> [accordion] Operational Integration
>
> **Field Operations:**
>
> * Coordinate with planned maintenance schedules
> * Integrate work orders with existing dispatch systems
> * Align investigation priorities with operational resources
> * Maintain equipment attribution accuracy through asset updates
>
> **Data Quality:**
>
> * Regular validation of asset attribution accuracy
> * Consistent source category classification
> * Complete documentation of manual observations
> * Verification of grouped observation relationships
## Common Variations
> [card] High-Volume Facility Scenario
>
> **Adaptation:** For facilities with frequent detections, establish standardized triage workflows with pre-defined follow-up request templates and automated grouping rules to handle volume efficiently while maintaining accuracy.
> [card] Remote Operations Scenario
>
> **Adaptation:** When field access is limited, emphasize detailed remote investigation through comprehensive data collection requests and leverage historical operational data to distinguish planned activities from genuine leaks.
> [card] Multi-Asset Complex Scenario
>
> **Adaptation:** For large facilities with multiple emission sources, establish asset attribution protocols with specific distance criteria and equipment identification procedures to ensure accurate source tracking across the complex.
> [card] Continuous Monitoring Integration
>
> **Adaptation:** When continuous monitoring systems are present, create automated workflows that correlate alarm data with satellite detections and establish thresholds for automatic vs. manual triage decisions.
## Troubleshooting & Best Practices
> [card] Do This
>
> **Start with Ops Comments for Uncertain Cases**
>
> Always begin with quick triage to avoid dispatching field crews to planned operational activities. This prevents resource waste and maintains crew availability for genuine emergencies.
> [card] Do This
>
> **Group Related Detections Before Creating Work Orders**
>
> Consolidate multiple detections of the same leak before initiating field work to ensure crews understand the complete scope and prevent duplicate investigations.
> [card] Not That
>
> **Don't Skip Attribution Verification**
>
> Incorrect attribution sends crews to wrong locations and creates inaccurate compliance data. Always verify and correct attribution before creating field work orders.
> [card] Not That
>
> **Don't Create Multiple Follow-up Requests for the Same Issue**
>
> Duplicate requests create confusion and waste resources. Check existing work items before creating new follow-up requests for the same emission event.
**Common Resolution Issues:**
* **Events Won't Auto-Close**: Check for missing equipment attribution, incomplete work orders, or unresolved continuous monitoring alarms
* **Volume Calculations Seem High**: Review grouped observations for duplicate time periods or incorrect emission rate data
* **Field Crews Report "Nothing Found"**: Verify attribution accuracy and check for recent operational activities that might explain the original detection
## Real-World Example
Acme Energy's Gulf Coast facility received a satellite methane detection alert on Tuesday morning near their main compressor station. Using the complete event management workflow, the operations team first sent an "Ops Comment" request to the morning shift supervisor, who confirmed no planned activities. They then corrected the attribution from the general facility to specific Compressor Unit 3, grouped it with a continuous monitoring alarm from the same time period, and created an OGI inspection request. The field technician found a leaking valve connection, completed the repair, and uploaded confirmation photos. The entire process—from detection to documented resolution—was completed within 18 hours with full audit trail.
> [!NOTE]
>
> **Result:** Reduced average investigation time from 3 days to 18 hours, eliminated 40% of unnecessary field dispatches, and achieved 100% audit readiness with complete documentation trails.
>
> **"This workflow transformed our methane response from reactive scrambling to systematic resolution. We now confidently meet all regulatory requirements while optimizing our field resources."**
> *- Environmental Manager, Gulf Coast Operations*
## Related Use Cases
> [card] [Emission Quantification Accuracy](/use-sensorup/emission-operations/emission-quantification)
>
> Learn how proper event management creates more accurate volume calculations through correct time boundaries and source attribution.
> [card] [Root Cause Analysis Investigation](/use-sensorup/emission-operations/event-management/getting-started-root-cause-analysis)
>
> Use investigation tools and operational context from event management to determine equipment failure patterns and prevent future incidents.
> [card] [Compliance Reporting Automation](/use-sensorup/emission-operations/insights-and-analytics)
>
> Transform properly managed emission events into automated compliance reports with accurate volume calculations and complete audit trails.
> [card] Preventive Maintenance Integration
>
> Connect emission event patterns with maintenance scheduling to address equipment issues before they become significant leak sources.
# Grouping Emission Observations
Source: https://docs.sensorup.com/use-sensorup/emission-operations/event-management/grouping-emission-observations
Combine multiple related emission observations into single, comprehensive events to prevent double-counting and improve accuracy.

## What is Observation Grouping?
Observation grouping allows you to combine multiple related emission observations into a single, comprehensive event record. This process prevents double-counting of emissions and creates a clearer understanding of the root cause, duration, and magnitude of methane leaks by consolidating data from different detection methods.
> [card] Prevent Double-Counting
>
> Avoid inflating emission totals
> [card] Combine Data Sources
>
> Unite flyover, CMS, and OGI data
> [card] Accurate Timeline
>
> Build complete event narratives
## Why Use Observation Grouping?
> [card] The Problem
>
> **Without observation grouping:**
>
> * Multiple detections of the same leak appear as separate events
> * Emission volumes are counted multiple times in reports
> * Incomplete understanding of leak duration and source
> * Difficulty distinguishing planned operations from fugitive leaks
> [card] The Solution
>
> **With observation grouping:**
>
> * Single, comprehensive record per actual emission event
> * Accurate emission quantification without double-counting
> * Complete timeline from first detection to final repair
> * Clear attribution between planned operations and unplanned leaks
## Common Use Cases
### Combining Detection Methods
**Scenario**: A continuous monitoring system (CMS) detects an ongoing emission, and later a flyover survey measures the same leak.
**Solution**: Group the CMS alarm with the flyover observation to use the CMS data for duration estimation while leveraging the more accurate flyover measurement for emission rate.
### Tracking Persistent Leaks
**Scenario**: Multiple flyover surveys detect the same leak over several weeks, followed by an OGI inspection that confirms the source.
**Solution**: Group all related observations to document the complete leak lifecycle from first detection through repair verification.
### Distinguishing Operational Events
**Scenario**: An emission is detected during a planned maintenance activity like a blowdown operation.
**Solution**: Associate the detection with the operational event to correctly categorize it as planned rather than a fugitive leak, ensuring proper resource allocation.
## Getting Started
> [!NOTE]
>
> **Ready to start grouping observations?** Follow these steps to create your first grouped emission event. The process takes just a few minutes and immediately improves your data accuracy.
**1. Open an Emission Event**
Navigate to the emission event you want to group with other observations. Click on the event in your timeline or search results to open the detailed view.
**2. Access Grouping Options**
In the emission event detail panel, look for the correlation options in the observations section. Click "Group Observations" to open the grouping interface.
**3. Select Related Events**
Choose from two grouping methods:
* **Add Existing**: Select from a time-ordered list of nearby emission events detected within 90 days
* **Create New**: Manually add observations with custom details and supporting evidence
**4. Review and Confirm**
Review the grouped observations to ensure they represent the same physical emission source. Confirm the grouping to create your consolidated emission event.
### Bulk merge
You can merge multiple emission events at once using bulk actions:
**1. Select events**
Select rows in the emissions table by clicking on them. To select multiple rows quickly, click on a row, hold Shift, and click on another row further down to select all rows in between.
**2. Choose merge**
At the bottom of the page, select **Merge**.
**3. Select primary event and confirm**
Choose a Primary Emission Event to merge the other events into and click **Confirm**. A success message will display to confirm the action was successful.
> [!TIP]
>
> To undo a merge, click on the event and in the Observations section, remove the Observations that were merged.
## Advanced Features
### Ungrouping Observations
Made a mistake? You can easily separate incorrectly grouped observations:
1. Select the observations that should be split into a new event
2. Confirm the separation to create independent emission events
3. The system maintains data integrity while preserving the audit trail
## Best Practices
> [card] Group Related Sources
>
> **Do**: Combine observations that clearly represent the same physical emission source, even if detected by different methods or at different times.
> [card] Avoid Over-Grouping
>
> **Don't**: Group observations that might be from different leaks or locations, as this can mask important patterns and reduce accuracy.
> [card] Verify Spatial Relationships
>
> **Do**: Check that grouped observations are from the same asset or equipment before correlating them.
> [card] Don't Rush Decisions
>
> **Don't**: Group observations without reviewing their temporal and spatial context, as incorrect grouping can impact reporting accuracy.
## FAQ / Troubleshooting
> [accordion] How do I know which observations should be grouped together?
>
> Look for observations that:
>
> * Occurred at the same asset or nearby equipment
> * Have overlapping or sequential time periods
> * Show similar emission characteristics
> * Are part of the same operational context (like a maintenance event)
> [accordion] What happens to emission calculations when I group observations?
>
> The system recalculates emission estimates using the most accurate data available:
>
> * Combines the best rate measurements with the most complete duration information
> * Prevents double-counting by consolidating overlapping time periods
> * Updates total volumes and reporting summaries automatically
> [accordion] Can I undo observation grouping if I make a mistake?
>
> Yes, you can ungroup observations at any time:
>
> * Select the specific observations you want to separate
> * Click "Ungroup" to create new independent emission events
> * The system maintains a complete audit trail of all grouping and ungrouping actions
> [accordion] How does grouping affect my regulatory reports?
>
> Observation grouping improves report accuracy by:
>
> * Eliminating double-counting of the same emission source
> * Providing more complete event documentation
> * Correctly categorizing planned vs. unplanned emissions
> * Maintaining full traceability for audit purposes
***
## Feedback & Support
> [!WARNING]
>
> **Found an issue with observation grouping?** Contact support with specific details about the observations you're trying to group, including event IDs and timestamps.
# Manually Add Observations to Event
Source: https://docs.sensorup.com/use-sensorup/emission-operations/event-management/manually-add-observations-to-event
Supplement automated emission detections with operational context to create complete, auditable records with accurate volume calculations.

## What is Manual Observation Creation?
The Manual Observation Creation feature allows you to supplement existing, system-detected emission events with operational observations that include specific timing, emission rates, and supporting documentation. This creates a complete, auditable story by combining automated sensor data with your on-ground operational knowledge.
> [card] 50% More Accurate
>
> Volume calculations using operational data
> [card] Complete Audit Trail
>
> Defensible documentation for compliance
> [card] 5-Minute Setup
>
> Quick addition of operational context
## Why Use Manual Observation Creation?
> [card] The Problem
>
> **Without manual observations:**
>
> * Automated detections miss operational context
> * Volume calculations based on incomplete data
> * Difficult to justify reported volumes during audits
> * No way to document known operational events
> [card] The Solution
>
> **With Manual Observation Creation:**
>
> * Combine sensor data with operational knowledge
> * Accurate volume calculations using ground-truth data
> * Complete audit trail with supporting documentation
> * Streamlined process for operational event documentation
## Getting Started
> [!NOTE]
>
> **Ready to add operational context to your emission events?** Follow these quick steps to create your first manual observation and see immediate improvements in data accuracy.
**1. Access an Emission Event**
Navigate to any existing emission event in your dashboard. Look for events that could benefit from additional operational context, such as those detected during known maintenance activities.
**2. Open the Manual Observation Form**
Click the "Add Observation" button or navigate to the "CreateNew" tab within the event details panel to access the manual observation creation interface.
**3. Complete Your First Observation**
Fill in the observation details including start/end times, emission rate, description, and upload any supporting files like maintenance logs or operational reports. The system will validate your inputs and create a comprehensive record.
## Common Use Cases
### Operational Event Documentation
When you have a known operational event (like a compressor blowdown or planned venting) that coincides with an automated detection, you can document the specific operational details to provide complete context and more accurate emissions calculations.
### Improving Volume Accuracy
Supplement sensor-based detections with precise operational data including exact timing and emission rates from your equipment specifications, leading to more accurate volume calculations for regulatory reporting.
### Creating Audit Defense
Build a robust audit trail by combining automated detections with operational documentation, maintenance logs, and descriptive context that demonstrates due diligence and accurate reporting practices.
## Key Features
### Comprehensive Data Entry
* **Timing Details**: Specify precise start and end times with timezone support
* **Emission Rates**: Enter accurate emission rates with configurable units (kg/hr, lb/hr)
* **Descriptions**: Add detailed operational context and explanations
* **File Uploads**: Attach supporting documentation like maintenance logs and reports
### Data Validation & Quality
* **Smart Validation**: Automatic checks ensure data integrity and logical consistency
* **Unit Conversion**: Seamless conversion between different measurement units
* **Timezone Handling**: Proper timezone management for accurate temporal data
* **File Management**: Support for various document types with size and format validation
### Integration & Workflow
* **Event Association**: Automatic linking to existing emission events
* **Volume Calculations**: Integration with time and rate engines for accurate quantification
* **Audit Trail**: Complete tracking of all additions and modifications
* **Permission Controls**: Role-based access to ensure data security
## Managing Observations
### Correcting Errors
If you need to correct a manual observation that was added in error:
1. **Remove from Event**: Use the ellipse menu to disassociate the observation from its parent event
2. **Mark as False Alarm**: Navigate to the removed observation and mark it as a false alarm
3. **Maintain History**: The system retains complete audit history for transparency
> [!WARNING]
>
> **Important**: Marking an observation as a false alarm will exclude it from all future volume calculations and reporting, but the audit trail is preserved for compliance purposes.
## FAQ / Troubleshooting
> [accordion] What types of files can I upload as supporting documentation?
>
> You can upload image files (JPEG, PNG) up to 10MB per file, with a maximum of 5 files per observation. These typically include maintenance logs, operational reports, or photos documenting the emission event.
> [accordion] How does adding a manual observation affect volume calculations?
>
> When you add a manual observation with specific timing and emission rate data, the system's time and rate engine will use this more precise operational data for volume calculations, typically resulting in more accurate emissions quantification than sensor-only estimates.
> [accordion] Can I edit a manual observation after it's been created?
>
> Manual observations maintain data integrity for audit purposes. If you need to make corrections, you should remove the observation from the event and mark it as a false alarm, then create a new observation with the correct information.
> [accordion] What permissions do I need to create manual observations?
>
> You need the "create EmissionObservation" permission in your user role. Contact your system administrator if you don't see the option to add manual observations to events.
> [accordion] How do manual observations appear in regulatory reports?
>
> Manual observations are integrated into the complete emission event record and their data (timing, rates, volumes) is included in regulatory reporting calculations. The operational context and supporting documentation provide audit defense for the reported values.
## Best Practices
> [card] Do This
>
> **Document Known Events**: Always add manual observations for planned operational events like blowdowns or venting
> **Upload Support Files**: Include maintenance logs, work orders, or photos as evidence
> **Be Specific**: Provide detailed descriptions with equipment IDs and operational context
> **Review Timing**: Ensure start/end times accurately reflect the operational event duration
> [card] Avoid This
>
> **Guessing Rates**: Don't estimate emission rates without operational data or specifications
> **Incomplete Context**: Don't leave descriptions vague or without specific operational details
> **Wrong Event Association**: Don't associate manual observations with unrelated automated detections
> **Missing Documentation**: Don't skip uploading supporting files when they're available
***
## Feedback & Support
> [!WARNING]
>
> **Found an issue or have suggestions?** Contact your system administrator or submit feedback through your organization's support channels for assistance with manual observation creation.
For additional help with emission event management and observation workflows, refer to your organization's EmissionOps documentation or contact your technical support team.
# Getting Started with Follow-up Requests
Source: https://docs.sensorup.com/use-sensorup/emission-operations/event-management/overview-of-follow-up-requests
Learn how to streamline your investigation and triage workflows by creating follow-up requests directly from emission events.

## Welcome!
Follow-up requests transform how you handle emission events by enabling you to initiate standardized investigation, triage, and resolution workflows directly from the platform. Instead of juggling multiple systems and manual processes, you can streamline everything from quick operational comments to complex field inspections with just a few clicks.
> [!NOTE]
>
> **Time Required:** 10 minutes to complete your first follow-up request
>
> **What You'll Learn:**
>
> * How to create your first follow-up request from an emission event
> * The different types of follow-up actions available
> * Best practices for streamlining your investigation workflows
> [!WARNING]
>
> **Before You Start:**
>
> * Your organization must have follow-up requests enabled for your account
> * You'll need appropriate permissions to create work items and requests
> * Some request types may require additional configuration by your administrator
## Your First Steps
**1. Navigate to an Emission Event**
Start by opening any emission event from your dashboard, timeline, or asset view. Look for events that need investigation or follow-up action.
The follow-up request options will appear as action buttons in the event details panel.
**2. Choose Your Follow-up Action**
Select the most appropriate follow-up request type for your situation:
**For Quick Triage:**
* **Ops Comment**: Get operator input on whether this is a known operational activity
* **Email Notification**: Alert supervisors about high-priority events
**For Detailed Investigation:**
* **Field Inspection Request**: Dispatch technicians for on-ground verification
* **Data Collection Form**: Capture structured information from operators

**3. Complete the Request Details**
Fill out the request form with relevant information:
* **Request description**: Explain what you need and why
* **Priority level**: Set urgency based on the event's significance
* **Recipients**: Add email addresses for people who should be notified
* **Attachments**: Include any supporting documents if needed
The form will guide you through the specific information needed for your chosen request type.
**4. Submit and Track**
Once submitted, your follow-up request creates a trackable work item that:
* Appears in your team's workflow management system
* Sends notifications to the people you specified
* Links back to the original emission event for full context
* Can be monitored for completion and results
> [!TIP]
>
> **You Did It!**
>
> ✅ Created your first standardized follow-up request
>
> ✅ Initiated a trackable workflow from an emission event
>
> ✅ Set up automatic notifications for your team
## Viewing and Managing Issues in the Emission Event Blade
After you create follow-up requests, the resulting Issues are accessible directly within the emission event detail view. You no longer need to navigate to the Issues page to check on work status or manage tasks.

> [!NOTE]
>
> When you open an emission event, a secondary blade (panel) displays all related Issues inline. This embedded Issues blade provides full parity with the Issues page, so you can stay in the emissions context while managing your work.
From the embedded Issues blade, you can:
* **View tasks and their current status**: See the progress of each follow-up request at a glance
* **Review results**: Check inspection findings, operator comments, and data submissions without leaving the emission event
* **Add comments**: Collaborate with your team by posting updates or asking questions directly on an Issue
* **Track status updates**: Monitor changes to Issue status as work moves through your organization's workflow
> [!TIP]
>
> Use the embedded Issues blade to quickly confirm whether a follow-up request has been addressed before creating additional requests for the same event.
## Types of Follow-up Requests
Understanding the different request types helps you choose the right workflow for each situation:
> [card] Ops Comment
>
> **Best For:** Quick triage to determine if an event is operational or a potential leak
>
> **What It Does:** Routes a question to operators who can provide context about planned activities or equipment status
>
> **Timeline:** Usually resolved within hours
> [card] Field Inspection
>
> **Best For:** Events that need visual confirmation or on-ground investigation
>
> **What It Does:** Creates a formal work order for technicians to visit the site and conduct inspection
>
> **Timeline:** Typically scheduled within 24-48 hours
> [card] Data Collection
>
> **Best For:** Gathering structured information about equipment, repairs, or operational activities
>
> **What It Does:** Sends custom forms to operators to capture specific details needed for your analysis
>
> **Timeline:** Response time varies based on form complexity
> [card] External Integration
>
> **Best For:** Organizations using external maintenance or field service systems
>
> **What It Does:** Automatically creates work orders in your existing systems without manual data entry
>
> **Timeline:** Immediate integration with external workflows
## Best Practices
> [card] Do This
>
> **Action:** Use Ops Comments first for quick triage
>
> **Why:** This helps you avoid dispatching resources to investigate known operational activities, saving time and costs.
> [card] Do This
>
> **Action:** Include specific details in your request descriptions
>
> **Why:** Clear context helps responders understand what you need and respond more effectively.
> [card] Not That
>
> **Action:** Don't create multiple requests for the same event without coordination
>
> **Why:** Duplicate requests can lead to confusion and wasted effort from your field teams.
> [card] Not That
>
> **Action:** Don't skip adding email recipients for urgent requests
>
> **Why:** Without notifications, important requests may sit unnoticed in work queues.
## Advanced Workflows
Once you're comfortable with basic follow-up requests, explore these advanced capabilities:
> [accordion] Mobile Integration
>
> Some organizations have follow-up requests that integrate directly with mobile field applications. When you create these requests, technicians receive them on their devices with:
>
> * GPS navigation to the event location
> * Event context and history
> * Forms for capturing inspection results
> * Photo and document upload capabilities
> [accordion] Custom Request Types
>
> Your organization can configure custom follow-up request types that match your specific operational procedures. These might include:
>
> * Specialized inspection protocols
> * Integration with regulatory reporting systems
> * Custom approval workflows
> * Automated escalation procedures
> [accordion] Batch Operations
>
> For events that are clearly related (such as multiple detections from the same leak), you can group them together and create a single follow-up request that covers all related observations, avoiding duplicate work.
## If You Get Stuck
> [accordion] I don't see any follow-up request options
>
> **Possible Causes:**
>
> * Follow-up requests aren't enabled for your organization
> * Your user account doesn't have the required permissions
> * The specific event type doesn't support follow-up requests
>
> **Solution:** Contact your system administrator to check your account settings and permissions.
> [accordion] My request was submitted but no one received notifications
>
> **Possible Causes:**
>
> * Email addresses were entered incorrectly
> * Recipients' email systems blocked the notification
> * There was a temporary system issue
>
> **Solution:** Check the request details to verify email addresses, and consider following up directly with recipients.
> [accordion] I need to cancel or modify a request after submitting
>
> **Solution:** Navigate to the work item created by your request. Depending on your system configuration, you may be able to update details or add comments. For urgent changes, contact the assigned recipient directly.
## What's Next?
Now that you understand follow-up requests, explore these related features to build more comprehensive workflows:
> [card] [Event Grouping](/use-sensorup/emission-operations/event-management/grouping-emission-observations)
>
> Learn how to group related emission observations before creating follow-up requests to avoid duplicate investigations.
> [card] [Root Cause Analysis](/use-sensorup/emission-operations/event-management/getting-started-root-cause-analysis)
>
> Discover how to use investigation tools and operational context to determine the source of emission events.
## The Art of the Possible: Custom Workflows
The true power of follow-up requests lies in their configurability. While you'll only see the request types your organization has enabled, the possibilities are extensive. By working with your Customer Success Manager, you can transform your company's unique operational processes into powerful, integrated workflows directly within the platform—from simple notifications to deep, bi-directional system integrations.
Whether you need to integrate with maintenance systems, dispatch mobile teams, or create custom approval workflows, follow-up requests can be tailored to match your existing processes while eliminating manual data entry and improving response times.
# Getting Started with Summary Insights
Source: https://docs.sensorup.com/use-sensorup/emission-operations/insights-and-analytics/getting-started-summary-insights
Learn how to analyze consolidated emission data and identify key contributors to optimize your leak detection and repair program.

## Welcome to Summary Insights!
Summary Insights provides a powerful, consolidated view of your emission data to help you quickly understand performance and identify the biggest contributors to your emissions profile. In just a few minutes, you'll learn how to access key metrics, prioritize your fieldwork, and generate compliance reports with confidence.
> [!NOTE]
>
> **Time Required:** 8-10 minutes for completion
> **What You'll Learn:**
>
> * Navigate emission summaries and identify top-emitting assets
> * Use multi-dimensional analysis to understand emission drivers
> * Filter data for specific time periods and compliance reporting
> [!WARNING]
>
> **Common Pitfalls:**
>
> * Not setting appropriate time ranges can lead to incomplete analysis
> * Focusing only on total mass without considering emission rates can miss critical issues
## Your First Steps
**1. Access Summary Insights**
Navigate to **EmissionOps** → **Insights & Analytics** → **Summary Insights** from your main dashboard. You'll see a comprehensive overview displaying both total emissions and average rates across your operations.
The main dashboard shows key performance indicators including total event count, average emission rates, and total mass for your selected time period and asset scope.
**2. Set Your Analysis Scope**
**Configure your time period and asset filters:**
* Select a time range (Last Month, Last Quarter, or Custom Range)
* Choose your asset scope (specific regions, business units, or individual assets)
* Apply any additional filters for event status or observation types
> [!NOTE]
>
> **Pro Tip:** Start with "Last Month" to get familiar with the data before expanding to longer time periods.
**3. Identify Top Contributors**
Review the **Top Emitting Assets** section to see which assets are contributing most to your total emissions. Each asset shows:
* Total emission mass and average rates
* Event count and current status breakdown
* Source category distribution (wellheads, compressors, tanks, etc.)
Click on any asset to see detailed breakdowns by equipment type and detection method.
**4. Analyze Performance Patterns**
Explore the **Detection Method Analysis** and **Equipment Type Analysis** sections to understand:
* Which observation types (satellite, drone, OGI camera) are finding the most emissions
* Which equipment categories need the most attention
* How event resolution status affects your overall emissions profile
> [!TIP]
>
> **You Did It!**
>
> ✅ You can now identify your highest-impact emission sources
>
> ✅ You understand how different detection methods perform in your operations
>
> ✅ You can prioritize fieldwork based on data-driven insights
## Quick Wins
Now that you've completed your first analysis, try these activities to build confidence with Summary Insights:
> [card] Generate a Compliance Report
>
> Filter your data to the last quarter and export a summary for regulatory reporting. **Time: 3 minutes**
> [card] Identify Weekly Priorities
>
> Filter to show only "open" events and sort by emission mass to create your team's weekly fieldwork list. **Time: 2 minutes**
> [card] Compare Detection Methods
>
> Analyze which observation types are most effective for different equipment categories in your operations. **Time: 5 minutes**
> [card] Asset Performance Review
>
> Compare emission performance across your top 10 assets to identify improvement opportunities. **Time: 4 minutes**
## If You Get Stuck
> [accordion] Why don't I see any data in my summary?
>
> This usually means your filters are too restrictive. Try expanding your time range or removing asset filters. Also verify you have the necessary permissions to view emission data for your selected scope.
> [accordion] How do I understand the breakdown data?
>
> Each asset, detection method, or equipment type can be broken down by multiple dimensions. Click on the breakdown charts to see how emissions are distributed by status (open/closed), source category, or observation type. This helps you understand the composition of emissions for better decision-making.
> [accordion] What's the difference between emission rate and total mass?
>
> Emission rate (kg/hour) shows the intensity of individual emissions, while total mass (kg) shows the cumulative impact over time. Use rates to identify severe individual incidents and mass to understand overall environmental impact and compliance obligations.
> [accordion] Can I compare different time periods?
>
> Yes! Use the time range selector to analyze different periods sequentially, or switch to Trend Insights for side-by-side temporal comparisons and month-over-month analysis.
## What's Next?
Great job completing your first summary analysis! Here are the logical next steps to expand your analytical capabilities:
> [card] [Explore Trend Analysis](/use-sensorup/emission-operations/insights-and-analytics/getting-started-trend-insights)
>
> Learn how to analyze patterns over time and measure the effectiveness of your improvement initiatives.
> [card] [Advanced Event Management](/use-sensorup/emission-operations/event-management/getting-started-with-event-management)
>
> Dive deeper into managing individual emission events and workflow optimization.
# Getting Started with Trend Insights
Source: https://docs.sensorup.com/use-sensorup/emission-operations/insights-and-analytics/getting-started-trend-insights
Learn how to analyze emission patterns over time, measure initiative effectiveness, and identify seasonal trends in your operations.

## Welcome to Trend Analysis!
Trend Insights provides powerful time-series visualization of your emission data to help you identify patterns, measure the effectiveness of operational changes, and understand seasonal variations in your emissions profile. You'll quickly learn how to track progress over time and demonstrate the impact of your improvement initiatives.
> [!NOTE]
>
> **Time Required:** 10-12 minutes for completion
> **What You'll Learn:**
>
> * Analyze monthly emission trends and identify patterns
> * Measure the effectiveness of maintenance protocols and operational changes
> * Compare performance across different time periods and initiatives
> [!WARNING]
>
> **Common Pitfalls:**
>
> * Analyzing too short a time period can miss important seasonal patterns
> * Not accounting for operational changes when interpreting trend data can lead to incorrect conclusions
## Your First Steps
**1. Access Trend Analysis**
Navigate to **EmissionOps** → **Insights & Analytics** → **Trend Insights** from your main dashboard. You'll see month-over-month emission trends displayed as interactive time-series charts showing both emission rates and total mass over time.
The main view displays your emission trends with clear month labels and the ability to hover over data points for detailed monthly breakdowns.
**2. Set Your Trend Analysis Period**
**Configure your analysis timeframe:**
* Select a time range spanning at least 6-12 months for meaningful trend analysis
* Choose your asset scope (regions, business units, or specific asset groups)
* Apply filters for specific event types or detection methods if needed
> [!NOTE]
>
> **Best Practice:** Start with a 12-month view to capture seasonal patterns and operational cycles.
**3. Identify Trend Patterns**
Examine the **Monthly Emission Trends** chart to understand:
* Overall trajectory (improving, stable, or degrading performance)
* Seasonal patterns in your emissions (higher/lower periods during certain months)
* Month-to-month variability and consistency in operations
Look for significant changes in slope that might correspond to operational improvements or equipment issues.
**4. Analyze Multi-Dimensional Trends**
Explore the breakdown charts to understand trends by different dimensions:
* **By Status**: Compare trends for open vs. closed events to see resolution improvements
* **By Equipment Type**: Identify which equipment categories are improving or degrading over time
* **By Detection Method**: Track the effectiveness of different observation technologies
> [!TIP]
>
> **You Did It!**
>
> ✅ You can now identify long-term emission patterns and trends
>
> ✅ You understand seasonal variations in your operations
>
> ✅ You can measure initiative effectiveness through before/after comparisons
## Quick Wins
Now that you've explored your first trend analysis, try these activities to deepen your understanding:
> [card] Measure Initiative Impact
>
> Identify a maintenance or operational change in your timeline and compare 3 months before vs. 3 months after. **Time: 5 minutes**
> [card] Find Seasonal Patterns
>
> Look for recurring monthly patterns (e.g., higher emissions in summer) to inform seasonal planning. **Time: 4 minutes**
> [card] Track Equipment Performance
>
> Filter trends by specific equipment types to identify which categories need proactive maintenance. **Time: 6 minutes**
> [card] Detection Technology Assessment
>
> Analyze trends by observation type to evaluate which detection methods are most effective over time. **Time: 5 minutes**
## If You Get Stuck
> [accordion] Why are my trends showing unexpected spikes or drops?
>
> Sudden changes often correspond to operational events, maintenance activities, or changes in detection technology. Check if there were facility shutdowns, equipment installations, or policy changes during those months. You can also filter to specific asset groups to isolate the source of variation.
> [accordion] How do I compare before/after effectiveness of an initiative?
>
> Set your time range to include several months before and after your initiative implementation. Look for sustained changes in the trend slope rather than single-month variations. Consider seasonal factors that might influence the comparison.
> [accordion] What if I don't see clear patterns in my data?
>
> This could indicate either stable operations (good!) or that patterns exist at different time scales. Try extending your analysis period to 18-24 months, or break down by specific asset groups or equipment types to find more granular patterns.
> [accordion] How do I switch between rate and mass analysis?
>
> Use the toggle in the chart controls to switch between emission rates (kg/hour) and total mass (kg). Rates show intensity patterns while mass shows total environmental impact over time. Both views provide complementary insights for different business decisions.
> [accordion] Can I preserve my filters when switching back to Summary Insights?
>
> Yes! Your filter settings persist when you navigate between Trend Insights and Summary Insights, allowing you to seamlessly analyze the same data from both temporal and aggregated perspectives.
## What's Next?
Excellent work on completing your first trend analysis! Here are recommended next steps to expand your analytical capabilities:
> [card] [Deep-Dive Summary Analysis](/use-sensorup/emission-operations/insights-and-analytics/getting-started-summary-insights)
>
> Use Summary Insights to investigate specific months or periods that showed interesting patterns in your trend analysis.
> [card] [Event Workflow Optimization](/use-sensorup/emission-operations/event-management/emission-event-statuses-v2)
>
> Learn how to optimize your event resolution workflows based on the status trend patterns you've identified.
# Getting Started with Emission Observation Dashboard
Source: https://docs.sensorup.com/use-sensorup/emission-operations/reporting-and-exports/getting-started-dashboard
Learn to explore, filter, and analyze your emission observation data in your first session with the interactive dashboard.
## Welcome!
The Emission Observation Dashboard is your command center for exploring and analyzing emission observation data. Whether you're validating new data sources, triaging operational issues, or preparing compliance reports, this guide will get you productive in your first session.
> [!NOTE]
>
> **Time Required:** 10-15 minutes for completion\
> **What You'll Learn:** How to view your data, create custom filters, and export results for further analysis
> [!WARNING]
>
> **Common Pitfalls:**
>
> * Remember that column preferences are saved per data source selection, so customize your view for each dataset you work with regularly
> * When viewing all observations, use filters to narrow down to the specific data you need before exporting
***
## Your First Steps
**1. Access the Dashboard**
Navigate to the **Observations** section from the main menu, then select your data scope using the **Data Source** dropdown:
* **All Observations** - View all your observations across every data source, then filter down using the table's filtering capabilities
* **Observation type** (FLY, SAT, etc.) - View all observations of a specific detection technology type
* **Individual data source** - View observations from a single specific data source
This flexibility allows you to create a single export containing only the observations you care most about, whether that's a comprehensive view or a focused subset.
You'll see two main areas:
* **Interactive map** showing observation locations with color-coded status indicators
* **Data table** with customizable columns and powerful filtering capabilities
**2. Understand Your Data Layout**
The dashboard loads with a default view combining observation, event, and asset data in one unified table.
**Default columns typically include:**
* Status (EE) - Current emission event status
* Asset Reference (EE) - Associated facility or asset
* Source Asset Reference (EE) - Attribution information
* Attribution Explanation (EE) - How the observation was linked
* Resolution Reason (EE) - Why events were resolved
* Short ID (EO) - Unique observation identifier
* Detected At (EO) - When the observation was recorded
* Start Date (EO) - Estimated emission start time
* End Date (EO) - Estimated emission end time
* Rate (EO) - Emission rate measurement
> [!NOTE]
>
> Fields that are empty across your entire dataset won't appear in the table or column options.
**Map Visualization:** Each point represents an observation location, with colors indicating the parent emission event status (red for Open, blue for Closed, etc.).
**3. Create Your First Filter**
Now let's find actionable data by filtering for open emission events that need attention.
1. Click the **Filter** button above the table
2. Select **ee\_status** from the field dropdown
3. Choose **equals** and select **Open**
4. Click **Apply Filter**
The table and map will update to show only observations associated with open emission events - these are your priority items requiring action.
**4. Customize Your View**
Tailor the dashboard to show exactly the information you need for your analysis.
**To customize columns:**
1. Click the **Columns** button at the top right of the table
2. Check or uncheck fields to add or remove them from your view
3. Your preferences will be automatically saved for this data source
**Pro tip:** If you work with specific emission rates, try adding rate-related columns or filtering for super-emitters by setting Rate > 100 kg/h.
> [!TIP]
>
> **Success! You're now ready to explore your data effectively.**
>
> ✅ You can view observations on both map and table\
> ✅ You've filtered data to find actionable items\
> ✅ You've customized your view for your specific needs
***
## Quick Wins to Build Your Skills
Try these additional tasks to become more proficient with the dashboard:
> [card] Export Filtered Data
>
> **Time:** 2-3 minutes\
> Select all observations or a specific type, apply filters to narrow down to exactly what you need, then click **Export** to download a CSV file with your customized data for offline analysis or reporting.
> [card] Explore Super-Emitters
>
> **Time:** 3-5 minutes\
> Set up a filter for Rate > 100 kg/h to quickly identify and analyze your highest-emission observations for compliance reporting.
> [card] Area-Specific Analysis
>
> **Time:** 5-7 minutes\
> Filter by business\_unit or operator fields to create focused reports for specific operational areas or teams.
> [card] Data Validation Workflow
>
> **Time:** 3-5 minutes\
> Use the dashboard to validate newly ingested data sources by viewing all raw observations and confirming data completeness.
***
## Common Use Cases
### Data Validation & Onboarding
**Perfect for:** Data managers and new users validating data feeds
* View newly ingested datasets to confirm successful import
* Verify data integrity before observations enter operational workflows
* Check for expected data fields and completeness
### Operational Triage & Planning
**Perfect for:** Environmental analysts and operators prioritizing work
* Filter for Open emission events to create daily action lists
* Use map visualization for geographical priority assessment
* Identify patterns in emission event status across your facilities
### Compliance & Reporting
**Perfect for:** Compliance managers and reporting analysts
* Generate super-emitter reports by filtering on emission rates
* Create area-specific reports using asset property filters
* Export customized datasets for regulatory submissions
### Advanced Analysis & Research
**Perfect for:** Data analysts and researchers
* Customize column views for specific data source analysis
* Export comprehensive datasets for external business intelligence tools
* Investigate long-term trends using historical observation data
***
## If You Get Stuck
> [accordion] I don't see the data I expected in my table
>
> Check if fields are empty across your dataset - columns with no data won't appear. Also verify that your current filters aren't excluding the data you're looking for. Try clearing all filters to see the complete dataset.
> [accordion] The map isn't showing all my observations
>
> Observations without valid coordinates won't appear on the map. Check your data for missing latitude/longitude information, or look for observations that are using asset reference locations instead of direct coordinates.
> [accordion] My column preferences aren't saving
>
> Column preferences are saved per data source automatically. If you're switching between different datasets (e.g., different detection technologies), each will have its own saved configuration. Make sure you're working with the correct data source.
***
## What's Next?
Now that you're comfortable with the basics, explore these advanced capabilities:
> [card] [Observation Data Model](/use-sensorup/emission-operations/technical-specifications/emission-observation-model)
>
> Understand the complete data structure and available fields to maximize your analysis capabilities.
> [card] [Emission Event Model](/use-sensorup/emission-operations/technical-specifications/emission-event-model)
>
> Learn about emission events and how observations flow into operational workflows.
# Data Model: Emission Event
Source: https://docs.sensorup.com/use-sensorup/emission-operations/technical-specifications/emission-event-model
The complete and finalized data dictionary for the Emission Event model, which groups multiple observations into a single event.
This model represents the parent-level **Emission Event**. An event is a container that groups one or more related Emission Observation records into a single, cohesive incident. It is used to track the event's overall duration, status, root cause, and total impact.
**Naming Convention:** The prefix `ee_` is consistently used to denote that these fields belong to the **E**mission **E**vent entity.
## Field Documentation
> [accordion] ee\_id — Event ID
>
> * **Description**: The unique, system-generated primary key for each emission event record.
> * **Data Type**: `UUID` or `Integer`
> * **Example**: `f1a2b3c4-d5e6-4567-8901-234567abcdef`
> [accordion] ee\_shortId — Short ID
>
> * **Description**: A concise, human-readable identifier for the event, used for quick reference in reports and UI.
> * **Data Type**: `String`
> * **Example**: `EVT-2025-00451`
> [accordion] ee\_status — Status
>
> * **Description**: The current workflow status of the overall emission event.
> * **Data Type**: `Enum` / `String`
> * **Notes**: Enum: `['Open', 'In Progress', 'Closed', 'False Alarm']`
> [accordion] ee\_statusReasons — Status Reasons
>
> * **Description**: An array of system-generated reasons that contribute to the current status of the emission event. These provide detailed context for why an event has a particular status.
> * **Data Type**: `Array` of `String`
> * **Notes**: Enum values: `['MISSING_START_TIME', 'MISSING_END_TIME', 'MISSING_SUB_SITE_ATTRIBUTION', 'CONTAINS_ALARM_ID', 'AUTO_CLOSED_OGI_OBSERVATION', 'HAS_WORK_ITEMS']`
> * **Example**: `["MISSING_START_TIME", "HAS_WORK_ITEMS"]`
> [accordion] ee\_statusExplanation — Status Explanation
>
> * **Description**: A free-text field that allows users to provide additional context when manually changing the status of an emission event. This field captures user-provided reasoning for status transitions.
> * **Data Type**: `String` (Text)
> * **Example**: `"Status updated to Closed after confirming repair completion and post-repair inspection"`
> [accordion] ee\_isDeleted — Is Deleted?
>
> * **Description**: A flag used for soft-deleting records. If `true`, the event is considered deleted and should not appear in standard queries.
> * **Data Type**: `Boolean`
> * **Example**: `false`
> [accordion] ee\_assetReference — Asset Reference
>
> * **Description**: The top-level asset from the customer's asset hierarchy. This is determined by taking the `eo_assetReference` from a child Emission Observation and traversing up the hierarchy to the top-most parent asset.
> * **Data Type**: `String`
> * **Notes**: Foreign Key to an 'Assets' table, representing the root asset for the event.
> [accordion] ee\_sourceAssetReference — Source Asset Reference
>
> * **Description**: A direct copy of the `eo_sourceAssetReference` from the underlying child Emission Observation. This represents the most granular source identified at the time of ingestion.
> * **Data Type**: `String`
> * **Notes**: Foreign Key to an 'Assets' or 'Components' table.
> [accordion] ee\_detectedAt — First Detection Timestamp
>
> * **Description**: The earliest detection timestamp from all the child Emission Observations linked to this event.
> * **Data Type**: `Timestamp` (ISO 8601)
> * **Example**: `2025-06-22T08:30:00Z`
> [accordion] ee\_startTime — Event Start Time
>
> * **Description**: The official start time of the entire emission event. This value is derived from the start times of the underlying child Emission Observations, based on a customer-configured priority of detection types. This logic is used for reconciliation and reporting.
> * **Data Type**: `Timestamp` (ISO 8601)
> * **Example**: `2025-06-22T08:25:00Z`
> [accordion] ee\_isStartTimeConfirmed — Is Start Time Confirmed?
>
> * **Description**: A flag to denote the origin of the start time. `true` indicates the `ee_startTime` was populated from an actual start time of an underlying Emission Observation. `false` indicates the time was estimated from other data (e.g., non-detects, default values) to set a duration.
> * **Data Type**: `Boolean`
> * **Example**: `false`
> [accordion] ee\_endTime — Event End Time
>
> * **Description**: The official end time of the entire emission event, which may be `null` if ongoing. This value is derived from the end times of the underlying child Emission Observations, based on a customer-configured priority of detection types.
> * **Data Type**: `Timestamp` (ISO 8601)
> * **Example**: `null`
> [accordion] ee\_isEndTimeConfirmed — Is End Time Confirmed?
>
> * **Description**: A flag to denote the origin of the end time. `true` indicates the `ee_endTime` was populated from an actual end time of an underlying Emission Observation. `false` indicates the time was estimated or defaulted.
> * **Data Type**: `Boolean`
> * **Example**: `false`
> [accordion] ee\_emissionsRate — Emissions Rate
>
> * **Description**: The official emissions rate for the event, used for reporting. This value is derived from the rates of the underlying child Emission Observations, based on a customer-configured priority of detection types.
> * **Data Type**: `Float` or `Decimal`
> * **Notes**: Units (e.g., kg/hr, scfh) must be standardized.
> [accordion] ee\_emissionsVolume — Emissions Volume
>
> * **Description**: The calculated total volume or mass of emissions for the duration of the event.
> * **Data Type**: `Float` or `Decimal`
> * **Notes**: Units (e.g., kg, scf) must be standardized. Calculated from rate and duration.
> [accordion] ee\_sourceCategory — Source Category
>
> * **Description**: The high-level category of the emission source, typically assigned during investigation.
> * **Data Type**: `Enum` / `String`
> * **Notes**: Recommended Enum: `['Fugitive', 'Vented', 'Combustion', 'Equipment Malfunction', 'Planned Maintenance']`
> [accordion] ee\_sourceEmissionsCause — Source Emissions Cause
>
> * **Description**: The specific root cause of the emission.
> * **Data Type**: `Enum` / `String`
> * **Notes**: Recommended Enum: `['Component Failure', 'Worn Seal', 'Improper Procedure', 'Upset Condition', 'Scheduled Blowdown']`
> [accordion] ee\_sourceExplanation — Source Explanation
>
> * **Description**: A free-text field for a detailed explanation of the event's root cause, investigation findings, and actions taken.
> * **Data Type**: `String` (Text)
> [accordion] ee\_sourceAttribution — Source Attribution
>
> * **Description**: A field to credit the team, individual, or system responsible for identifying the root cause of the event.
> * **Data Type**: `String`
> * **Example**: `"LDAR Team B"`, `"Analytics Model #4"`
> [accordion] Observation Counts
>
> * **Description**: These fields provide a summary count of all child Emission Observations linked to this event, broken down by their detection type.
> * **Data Type**: `Integer`
> * **Fields**:
> * `ee_observationCountsCMS`: Continuous Monitoring System
> * `ee_observationCountsFLY`: Flyover / Aerial Survey
> * `ee_observationCountsSAT`: Satellite
> * `ee_observationCountsOGI`: Optical Gas Imaging
> * `ee_observationCountsMNL`: Manual Entry / Operator Sighting
> * `ee_observationCountsVFB`: Venting, Flaring, or Blowdown (Operational Event)
> * `ee_observationCountsDRN`: Drone
> * `ee_observationCountsOWD`: Operator Walk-down
> * `ee_observationCountsEME`: Emergency System Alert
> * `ee_observationCountsNOD`: No Detection (e.g., from a scheduled inspection that found nothing)
> * `ee_observationCountsUNK`: Unknown
> [accordion] ee\_group — Tenant
>
> * **Description**: The identifier for the tenant (customer) in the SensorUp system that this emission event belongs to.
> * **Data Type**: `String`
> * **Example**: `"customer-acme-inc"`, `"9e8b1b0e-a2f0-4a8a-a2b8-9d5d852673c6"`
# Data Model: Emission Observation
Source: https://docs.sensorup.com/use-sensorup/emission-operations/technical-specifications/emission-observation-model
A complete data dictionary for the Emission Observation model, detailing each field.
This model is designed to capture all relevant information about a single, detected emission event. It tracks the event from initial detection through compliance and resolution, linking it to specific assets and supporting media.
**Naming Convention:** The prefix `eo_` is consistently used to denote that these fields belong to the **E**mission **O**bservation entity.
## Field Documentation
> [accordion] eo\_id — Observation ID
>
> * **Description**: The unique, system-generated primary key for each emission observation record.
> * **Data Type**: `UUID` or `Integer`
> * **Deprecated**: No
> * **Example**: `a1b2c3d4-e5f6-7890-1234-567890abcdef`
> [accordion] eo\_shortId — Short ID
>
> * **Description**: A concise, human-readable identifier for the observation, often used for quick reference in reports and UI.
> * **Data Type**: `String`
> * **Deprecated**: No
> * **Example**: `OBS-2025-00123`
> [accordion] eo\_assetReference — Asset Reference
>
> * **Description**: A reference to the asset associated with the emission. This link is either provided directly by a third-party data source or is programmatically inferred by the SensorUp platform based on the geographical proximity of the emission to a known asset during data ingestion.
> * **Data Type**: `String`
> * **Deprecated**: No
> * **Notes**: Foreign Key to an 'Assets' table. Can be an ID or name.
> [accordion] eo\_sourceAssetReference — Source Asset Reference
>
> * **Description**: A reference to the most finite (granular) source of the emission as provided during data ingestion. This is often a specific piece of equipment, component, or instrument identified by a third-party data source.
> * **Data Type**: `String`
> * **Deprecated**: No
> * **Notes**: Foreign Key to an 'Assets' or 'Components' table.
> [accordion] eo\_screeningId — Screening ID
>
> * **Description**: An identifier that links this observation to a broader screening or inspection event.
> * **Data Type**: `String` or `Integer`
> * **Deprecated**: No
> * **Notes**: Foreign Key, likely referencing a 'Screening Events' table.
> [accordion] eo\_detectedAt — Detection Timestamp
>
> * **Description**: The exact date and time when the emission was first detected by the source asset.
> * **Data Type**: `Timestamp` (ISO 8601)
> * **Deprecated**: No
> * **Example**: `2025-06-23T10:15:00Z`
> [accordion] eo\_startTime — Event Start Time
>
> * **Description**: The official start time of the emission event being observed.
> * **Data Type**: `Timestamp` (ISO 8601)
> * **Deprecated**: No
> * **Example**: `2025-06-23T10:14:30Z`
> [accordion] eo\_endTime — Event End Time
>
> * **Description**: The official end time of the emission event. This may be `null` if the emission is ongoing.
> * **Data Type**: `Timestamp` (ISO 8601)
> * **Deprecated**: No
> * **Example**: `2025-06-23T11:05:00Z` or `null`
> [accordion] eo\_detectionType — Detection Type
>
> * **Description**: The method or technology used to detect the emission.
> * **Data Type**: `Enum` / `String`
> * **Deprecated**: No
> * **Notes**: Recommended Enum: `['OGI', 'Sensor', 'Aerial', 'Manual', 'Auditory']`
> [accordion] eo\_inputType — Input Type
>
> * **Description**: Describes how the observation data was entered into the system.
> * **Data Type**: `Enum` / `String`
> * **Deprecated**: No
> * **Notes**: Recommended Enum: `['Automated Feed', 'Manual Entry', 'File Upload']`
> [accordion] eo\_detectionSource — Detection Source Name
>
> * **Description**: A descriptive name for the specific source of the detection (e.g., a sensor ID or operator's name).
> * **Data Type**: `String`
> * **Deprecated**: No
> * **Example**: `"Drone #A42-ZULU"`, `"Sensor #GH-5501"`
> [accordion] eo\_emissionsRate — Emissions Rate
>
> * **Description**: The quantified rate of the emission. Units should be standardized across the system.
> * **Data Type**: `Float` or `Decimal`
> * **Deprecated**: No
> * **Example**: `15.75` (Units like kg/hr or scfh should be explicit).
> [accordion] eo\_status — Status
>
> * **Description**: The current workflow status of the emission observation.
> * **Data Type**: `Enum` / `String`
> * **Deprecated**: No
> * **Notes**: Recommended Enum: `['New', 'Investigating', 'Resolved', 'Closed']`
> [accordion] eo\_createdBy — Created By
>
> * **Description**: The user ID or process that created the record in the system.
> * **Data Type**: `String` or `Integer`
> * **Deprecated**: No
> * **Notes**: Foreign Key to a 'Users' table or system process name.
> [accordion] eo\_createdTime — Created Timestamp
>
> * **Description**: The timestamp of when this observation record was created in the system.
> * **Data Type**: `Timestamp` (ISO 8601)
> * **Deprecated**: No
> * **Example**: `2025-06-23T14:35:00Z`
> [accordion] eo\_updatedBy — Updated By
>
> * **Description**: The last user or process that updated this record.
> * **Data Type**: `String` or `Integer`
> * **Deprecated**: No
> * **Notes**: Foreign Key to a 'Users' table.
> [accordion] eo\_updatedTime — Updated Timestamp
>
> * **Description**: The timestamp of the most recent update made to this record.
> * **Data Type**: `Timestamp` (ISO 8601)
> * **Deprecated**: No
> * **Example**: `2025-06-23T14:35:00Z`
> [accordion] eo\_s3MediaUrls — Media URLs
>
> * **Description**: A list of Uniform Resource Locators (URLs) pointing to supporting media files (e.g., images, videos) stored in an AWS S3 bucket.
> * **Data Type**: `Array` of `String` (URL)
> * **Deprecated**: No
> * **Example**: `["https://.../img1.jpg", "https://.../vid1.mp4"]`
> [accordion] eo\_emissionEventId — Emission Event ID
>
> * **Description**: An identifier used to group multiple, related observations into a single overarching emission event.
> * **Data Type**: `String` or `Integer`
> * **Deprecated**: No
> * **Example**: `EVT-LEAK-558`
### Deprecated Fields
The following fields are deprecated and should not be used for new development. They are maintained for historical data purposes only.
> [accordion] eo\_lastComplianceActionAt — Last Compliance Action
>
> * **Description**: The timestamp of the most recent compliance-related action taken for this observation.
> * **Data Type**: `Timestamp` (ISO 8601)
> * **Deprecated**: Yes
> [accordion] eo\_complianceDeadline — Compliance Deadline
>
> * **Description**: The regulatory or internal deadline by which compliance actions must be completed for this observation.
> * **Data Type**: `Date` or `Timestamp`
> * **Deprecated**: Yes
> [accordion] eo\_acknowledged — Is Acknowledged?
>
> * **Description**: A flag indicating whether a user has officially reviewed and acknowledged the observation.
> * **Data Type**: `Boolean`
> * **Deprecated**: Yes
> [accordion] eo\_equipmentComponentName — Equipment Component
>
> * **Description**: The specific name or identifier of the equipment component associated with the emission.
> * **Data Type**: `String`
> * **Deprecated**: Yes
> [accordion] eo\_acknowledgedBy — Acknowledged By
>
> * **Description**: The user ID or name of the person who acknowledged the emission observation.
> * **Data Type**: `String` or `Integer`
> * **Deprecated**: Yes
> [accordion] eo\_acknowledgedTime — Acknowledged Timestamp
>
> * **Description**: The date and time when the observation was acknowledged by a user.
> * **Data Type**: `Timestamp` (ISO 8601)
> * **Deprecated**: Yes
# Audit History
Source: https://docs.sensorup.com/use-sensorup/field-operations/audit-history
Track every change made to an issue and task with a complete, chronological audit trail for compliance and accountability.
## What is Audit History?
Audit History is your complete audit trail for field operations and office workflows. Every action taken on an issue or task—from creation to resolution—is automatically logged with timestamps and user attribution. Whether you're auditing a site inspection for compliance, resolving conflicting information in a leak report, or managing field teams and office staff working remotely, Audit History provides the permanent, unchangeable record you need to maintain accountability and operational visibility.
> [card] 100% Accountability
>
> See exactly who did what and when
> [card] Real-Time Visibility
>
> Track mobile app actions instantly in web
> [card] Compliance Ready
>
> Permanent audit trail for regulatory requirements
## Why Use Audit History?
> [card] The Problem
>
> **Without issue & task history:**
>
> Hours wasted manually reconstructing audit trails
>
> No visibility into asynchronous field operations and office work
>
> Can't trace conflicting data changes
>
> Disputes about who did what and when
> [card] The Solution
>
> **With Issue & Task History:**
>
> Automatic compliance documentation
>
> Real-time mobile-to-web visibility
>
> Complete edit history with timestamps
>
> Eliminates disputes with definitive records
## Getting Started
> [!NOTE]
>
> **Ready to use Audit History?** The feature is automatically enabled for all issues and tasks. No setup required—just open any issue to view its complete history.
**1. Open an Issue**
Navigate to any issue in your Work Management dashboard and click to open the issue details blade.
**2. Access the History Tab**
Click the "History" tab in the issue details blade to view the complete audit log.
**3. Review the Timeline**
Scroll to the **bottom** to see the issue creation (oldest entry), then scroll up to follow the lifecycle to the current state (newest entries at top).
Each entry shows:
* **What changed**: Property, form field, or action
* **Who made it**: User name or "System"
* **When it occurred**: Exact timestamp
* **Before/After values**: For property and form changes
> [!WARNING]
>
> **Important**: History displays in chronological order with **oldest entries at the bottom**. Scroll to the bottom to find when the issue was created, then read upward to follow its progression.
## What Gets Tracked?
Audit History captures comprehensive details across three categories:
### Issue Properties
Core issue attributes that change over time:
* **Title and Description**: Updates to issue identification and details
* **Severity Level**: Priority increases or decreases
* **Status**: Opens, closes, reopens
* **Due Date**: Deadline assignments, modifications, or removals
* **Assignment**: Assignee additions, changes, or removals
* **Watchers**: Team members added or removed from notifications
* **Resolution**: Closure reasons and false alarm markings
### Task Lifecycle and Data Collection
Work performed by field teams and office staff using Site Check-in and OGI Inspection tasks:
* **Task Creation**: Initial creation timestamp and creator (e.g., "Site Check-in Task Created")
* **Task Progress**: Start, stop, complete, restart actions
* **Form Submissions**: Data collected during inspections
* **Field-level tracking**: See exactly which questions were answered (e.g., "Leak Observed = Yes")
* **Initial vs. Update**: Distinguish first data entry from corrections
* **Before/After values**: Compare original and modified results
* **Human-readable labels**: Form questions shown in plain language, not technical IDs
### Comments and Annotations
Team collaboration and notes:
* **Comment additions**: Who added what note and when
* **Comment modifications**: Edits to existing annotations
* **Comment deletions**: Removed annotations (action is logged, not comment content)
> [!NOTE]
>
> **Cross-Platform Tracking**: Actions performed in the Outpost mobile app by field operators appear instantly in the web control plane. Operations managers can track field progress in real-time without phone calls or status check-ins.
## Understanding History Entries
### Entry Components
Every history entry includes:
| Component | Description | Example |
| - | - | - |
| **Event Time** | Exact timestamp of the action | "2025-11-17 14:32:15 UTC" |
| **Event Type** | Classification of the action | "Issue Assigned", "Task Completed" |
| **Trigger Type** | User or System initiated | "user" or "system" |
| **User Information** | Who performed the action | "John Smith" or "System" |
| **Property Changes** | What changed and how | "Severity: 2 → 3" |
| **Version Number** | Sequential version for tracking | "Version 15" |
### Types of History Entries
#### Property Changes
Standard issue attributes changing:
```
Event Type: Issue Severity Increased
Changed By: Sarah Johnson
Timestamp: 2025-11-17 10:15:23 UTC
Property: Severity
Old Value: 2 (Medium)
New Value: 3 (High)
```
#### Form Submissions
Data collected during field operations and office tasks:
```
Event Type: Issue State Data Updated
Changed By: Mike Chen (via Outpost mobile app)
Timestamp: 2025-11-17 11:42:08 UTC
Form Fields Changed:
- Leak Observed: "Yes"
- H2S Detected: "No"
- Tag Number: "COMP-4421"
```
**Initial Entry vs. Update**:
* **First submission**: Only new values are shown (no old value displayed)
* **Corrections/Updates**: Both old and new values shown for comparison
#### Comments and Annotations
Team notes and collaboration:
```
Event Type: Issue Annotated
Author: David Lee
Timestamp: 2025-11-17 13:20:45 UTC
Comment: "Spoke with site supervisor. Leak is accessible but requires scaffolding."
```
#### Task Completions
Field operations and office work milestones:
```
Event Type: Issue Task Completed
Changed By: Mike Chen (via Outpost mobile app)
Timestamp: 2025-11-17 12:05:33 UTC
Task: Site Check-In
Status: Open → Complete
```
### User vs. System Changes
History clearly distinguishes action sources:
* **User**: Person performed the action (shows their name)
* **System**: Automated action (shows "System")
System actions include:
* Automated integrations creating issues
* Scheduled workflow triggers
* Calculated field updates
* Automated status changes based on rules
## Common Use Cases
**Compliance Auditing**
When your facility undergoes a regulatory audit, Audit History provides complete documentation showing when inspections were performed, which field operators and office staff completed them, and the full data collection process from start to finish. The permanent, unchangeable audit trail demonstrates accountability without requiring manual documentation.
**Resolving Data Discrepancies**
When you notice conflicting information in reports, Audit History lets you trace every edit back to the specific task and form submission. See when original data was entered versus when it was corrected, identify which field operator or office staff member made each entry, and use timestamped comments to understand the context and coach team members on proper procedures.
**Managing Asynchronous Field Operations and Office Work**
Track your field team's and office staff's progress in real-time as they work remotely using the Outpost mobile app or web interface. View updates as tasks are completed, see when specific tasks are marked "Complete," and finalize issues in your triage process immediately when field operations and office work is done—all without making phone calls for status updates.
**Verifying Work Completion**
During daily triage, verify that high-priority issues have been properly addressed before closing them. Review the complete task history from creation to completion, verify all required form data was collected, check that proper procedures were followed, and confirm who performed the work and when.
**Dispute Resolution**
When there's disagreement about when an issue was reported or what actions were taken, Audit History provides definitive timestamps for all actions, shows original issue details exactly as created, and documents every assignment change and status update. The permanent, unchangeable record eliminates disputes with factual evidence.
## FAQ / Troubleshooting
> [accordion] Can I edit or delete history entries?
>
> No. Audit History is an immutable audit trail. Once logged, entries become permanent records that cannot be edited or deleted. This ensures data integrity for compliance audits and prevents tampering with historical records.
> [accordion] Why do some entries show 'System' instead of a user name?
>
> Some changes are triggered automatically by system processes rather than manual user actions. Examples include:
>
> * Issues created by automated integrations
> * Calculated field updates
> * Scheduled workflow triggers
>
> The "System" label helps you distinguish automated actions from manual ones.
> [accordion] Why do I see multiple entries for one action?
>
> Some actions affect multiple properties simultaneously. For example, closing an issue updates:
>
> * Status (Open → Closed)
> * Closed timestamp
> * Closer user ID
> * Resolution reason
>
> Each property change gets its own entry for complete transparency and granularity.
> [accordion] How do I find when an issue was first created?
>
> Scroll to the **bottom** of the history log. History displays chronologically with oldest entries at the bottom. The very first entry shows issue creation details including who created it and when.
> [accordion] Can I see what field operators are doing in real-time?
>
> Yes. Actions performed in the Outpost mobile app appear instantly in the web control plane. You can track:
>
> * Task starts and completions
> * Form data submissions
> * Comments added from the field
> * Status updates
>
> This eliminates the need for status phone calls during field operations.
> [accordion] How can I tell if data was corrected after initial entry?
>
> Form submission entries clearly show initial vs. update:
>
> * **Initial entry**: Only new values are displayed (no old values shown)
> * **Update/Correction**: Both old and new values are displayed side-by-side for comparison
>
> This distinction helps you verify data accuracy and identify when corrections were made.
> [accordion] What's the difference between property changes and form submissions?
>
> * **Property changes**: Core issue attributes like title, severity, assignment, due date, status
> * **Form submissions**: Structured data collected during tasks (e.g., inspection checklists, observation details)
>
> Both are tracked separately. Form submissions show field-level detail with human-readable labels like "Leak Observed" instead of technical field IDs.
> [accordion] Can I export history for compliance reporting?
>
> Yes. Audit history is available through the GraphQL API for export and reporting. Contact your system administrator for:
>
> * API access credentials
> * Query examples
> * Export capabilities
> * Integration with compliance reporting tools
> [accordion] How far back does history go?
>
> History captures every event from issue creation onward with no time limit. The complete audit trail is preserved for the entire lifecycle of the issue, ensuring permanent records for compliance and accountability.
> [accordion] Why don't I see old values for comments?
>
> Comments are treated as independent additions rather than updates to existing content. Each comment is a new contribution with no "old value" to compare against.
>
> However, if a comment is edited or deleted, that *action* is logged separately showing what changed.
> [accordion] What happens if form schema isn't available?
>
> If the form schema cannot be loaded, you'll still see form data changes, but field labels may not be as descriptive. The system will display technical field identifiers instead of human-readable labels.
>
> This is rare and typically resolves automatically. Contact support if you consistently see technical IDs instead of field labels.
> [accordion] Can I filter history to show only certain types of changes?
>
> Currently, the history view shows all changes chronologically. For advanced filtering and analysis, use the GraphQL API to query specific event types or date ranges. Contact your system administrator for API access.
***
## Related Features
> [card] [Issue Management](/use-sensorup/connected-operations/issue-management/overview)
>
> Learn how to create, manage, and resolve issues in Work Management.
> [card] [Outpost Mobile App](/use-sensorup/outpost-mobile/overview)
>
> Discover how field operators use the mobile app to complete tasks that generate history entries.
## Feedback & Support
> [!WARNING]
>
> **Found a bug or issue?** If you notice discrepancies in the issue history or have questions about specific entries, contact your system administrator or support team with the issue ID and specific history entry details.
Have questions or suggestions about Audit History? We're here to help improve your experience.
# Inspections Dashboard
Source: https://docs.sensorup.com/use-sensorup/field-operations/dashboards/inspections
View and manage OGI inspection issues with the Inspections dashboard.
The Inspections tab provides a centralised view of all OGI inspection issues across your sites. Use this tab to track inspection progress, view assigned field technicians, and monitor the number of leaks and vents discovered during each inspection.
> [!NOTE]
>
> **What you'll learn:**
>
> * How to view and filter OGI inspections
> * How to understand inspection statuses
> * How to use the detail blade to review inspection data
> [!NOTE]
>
> **Data source:** This tab displays [Issues](/use-sensorup/field-operations/issues-tasks/overview) — specifically OGI inspection issues. The detail blade is the same as the standard Issue detail view.
## Before you start
Ensure you have:
* Access to the Fugitive Emission Dashboards feature
* Viewer role or higher to view inspection data
* At least one site with OGI inspection issues
## Understanding the Inspections tab
### Inspection statuses
Each inspection has one of the following statuses:
| Status | Colour | Description |
| - | - | - |
| **Scheduled** | Blue | Inspection is planned but not yet started |
| **In Progress** | Yellow | Field technician is actively conducting the inspection |
| **Completed** | Green | Inspection has been finished |
### Data displayed
The Inspections table shows key information for each inspection:
* **Site Name** — The site where the inspection takes place
* **Survey Date** — The date when the Site Check-in survey was completed
* **Field Technician** — The assigned technician
* **Number of Leaks** — Count of leaks discovered during the inspection
* **Number of Vents** — Count of vents documented during the inspection
* **Status** — Current inspection status

## Viewing and filtering inspections
**1. Open the Inspections tab**
Navigate to the Fugitive Emission Dashboards and select the **Inspections** tab from the tab bar.
**2. Filter by site**
Use the **Site** dropdown in the toolbox to filter inspections for a specific site, or clean up the filter to view all inspections.
**3. Set the date range**
Choose a date range to narrow down the results:
* **Today**, **Last 7 Days**, **This Month**, **This Quarter**, **This Year**
The date filter applies to the **Last Updated** field.
**4. Filter by status**
Click on status badges in the legend to show or hide inspections by status. Active statuses are highlighted; click again to toggle visibility.
**5. Search by site name**
Use the search field to find inspections by site name.
## Using the detail blade
Click on any inspection row in the table or marker on the map to open the detail blade. The detail blade provides the same view as the standard [Issue detail view](/use-sensorup/field-operations/issues-tasks/overview).

### Details tab
The Details tab displays:
* Issue metadata (title, description, severity, due date)
* Linked asset information
* Form responses
* Comments and communication history
## Tips for efficient inspection management
> [accordion] Use map view for geographic context
>
> Switch to **Map view** to see inspections plotted geographically. This helps identify coverage patterns and prioritise sites based on location.
> [accordion] Group by status for progress tracking
>
> In the table, group rows by **Status** to quickly see how many inspections are scheduled, in progress, or completed.
> [accordion] Monitor leak and vent counts
>
> Pay attention to the leak and vent counts to identify inspections that may require follow-up actions or additional attention.
## Related resources
* [Issues Overview](/use-sensorup/field-operations/issues-tasks/overview) — Learn about creating and managing issues
* [Leaks Dashboard](/use-sensorup/field-operations/dashboards/leaks) — View and manage detected leaks
* [Vents Dashboard](/use-sensorup/field-operations/dashboards/vents) — Track venting devices
* [Outpost Mobile](/use-sensorup/outpost-mobile/overview) — Complete inspections on mobile devices
# Leaks Dashboard
Source: https://docs.sensorup.com/use-sensorup/field-operations/dashboards/leaks
View and manage detected leaks with the Leaks dashboard.
The Leaks tab provides a view of all detected leaks across your sites. Use this tab to monitor leak status, track repair compliance, edit leak data, create follow-up actions, and export data for reporting.
> [!NOTE]
>
> **What you'll learn:**
>
> * How to view and filter leak data
> * How to use map and table views
> * How to edit leak records
> * How to create follow-up actions
> * How to export leak data
> [!NOTE]
>
> **Data source:** This tab displays [Form Responses](/use-sensorup/field-operations/forms/overview) — specifically Leak form responses captured during [inspections](/use-sensorup/field-operations/dashboards/inspections).
## Before you start
Ensure you have:
* Access to the Fugitive Emission Dashboards feature
* Viewer role or higher to view leak data
* Editor role or higher to edit records and export data
## Understanding the Leaks tab
### Leak statuses
Each leak has one of the following statuses:
| Status | Colour | Description |
| - | - | - |
| **Leaking** | Red | Active leak requiring repair |
| **Delayed** | Orange | Repair is delayed beyond the compliance window |
| **Repair Verified** | Green | Leak has been repaired and verified |
| **Not Leaking** | Grey | Leak is no longer active or has been re-verified |
### Key data fields
The Leaks table displays important information for each leak:
* **Leak ID** — Unique identifier for the leak
* **Site** — The site where the leak was detected
* **Detection Date** — When the leak was first identified
* **Emissions Rate** — Measured emissions rate
* **Component** — The equipment component where the leak occurs
* **Process Block** — The process area within the site
* **Source Description** — Details about the leak source
* **Status** — Current leak status
* **Repair Compliance** — Time remaining or overdue status
## Viewing and filtering leaks
**1. Open the Leaks tab**
Navigate to the Fugitive Emission Dashboards and select the **Leaks** tab from the tab bar.
**2. Choose your view mode**
Select the view that works best for your task:
* **Split view** — See both map and table side-by-side
* **Map view** — Full-screen map with colour-coded markers
* **Table view** — Full-screen data grid with all columns
**3. Filter by site**
Use the **Site** dropdown to filter leaks for a specific site, or clean up the filter to view all leaks.
**4. Set the date range**
Choose from preset date ranges or set a custom range. You can filter by:
* **Detected** — Filter by the detection date (when the leak was first identified)
* **Updated** — Filter by the last updated date (when the leak record was last modified)
**5. Filter by status**
Click on status badges in the legend to show or hide leaks by status. This is useful for focusing on active leaks requiring attention.
**6. Search by Leak ID**
Use the search field to find a specific leak by its Leak ID.
**7. Toggle historical data**
Use the historical data toggle to include or exclude records imported from previous systems.
## Using map and table views
### Map view
The map displays leaks as colour-coded markers based on their status. Interact with the map to:
* **Zoom and pan** to navigate to different areas
* **Click markers** to open the detail blade
* **Use spatial filtering** to filter by the current map viewport
### Table view
The table provides a detailed data grid with:
* **Sortable columns** — Click column headers to sort
* **Groupable columns** — Group by Site, Component, Process Block, or Status
* **Column visibility** — Show or hide columns as needed
* **Row highlighting** — Hover highlights corresponding map marker

## Using the detail blade
Click on any leak row or map marker to open the detail blade.

### Details tab
The Details tab displays:
* Leak metadata (ID, status, detection date)
* Form response data (emissions rate, component, source description)
* Media attachments (photos, videos from field inspection)
* Repair information (repair date, verification date)
### Single PDF export
You can export an individual leak record as a PDF from the detail blade.
**1. Open the detail blade**
Click on a leak to open its detail blade.
**2. Click the PDF button**
Click the **PDF** action button in the detail blade header.
**3. Download the file**
The PDF file will be generated and downloaded to your device.
### History tab
The History tab shows a timeline of:
* Initial detection
* Status changes
* Related form submissions (repairs, verifications)
## Editing leak data
Editors and administrators can update leak records directly from the dashboard.
**1. Open the detail blade**
Click on a leak to open its detail blade.
**2. Click Edit**
Click the **Edit** button to open the edit modal.
**3. Modify the data**
Update the form response fields as needed. Changes are validated before saving.
**4. Save changes**
Click **Save** to apply your changes. The dashboard will update to reflect the new data.

## Creating follow-up actions
Create linked issues from leak records to trigger repairs, verifications, or other follow-up tasks.
**1. Open the detail blade**
Click on a leak to open its detail blade.
**2. Select a follow-up action**
Click one of the available follow-up action buttons (for example, **Repair and Verify**).
**3. Complete the form**
The follow-up form opens pre-populated with relevant leak data. Fill in any additional required fields.
**4. Submit the issue**
Submit the form to create a linked issue. The new issue will appear in the Issues module and can be assigned to field technicians.

> [!NOTE]
>
> **Follow-up actions** create traceable links between leak records and repair/verification issues, ensuring audit trails for compliance.
## Exporting leak data
Export filtered leak data to Excel for reporting and analysis.
**1. Apply filters**
Use the filtering tools to narrow down the data in the table you want to export.
**2. Click Export**
Click the **Export** button in the toolbar.
**3. Download the file**
Click **Export** to download the Excel file to your device.

### Batch PDF export
You can also export multiple leaks as a single PDF for documentation or sharing.
**1. Click Export**
Click the **Export** button in the toolbar.
**2. Select Batch PDF**
Select the **Batch PDF** option to open the export modal.
**3. Customize export options**
Select the date range, site, and status filters you want to apply.
**4. Start the export**
Click the **Export** button to generate the PDF.
**5. Download the file**
Once complete, the combined PDF file downloads to your device.

## Tips for efficient leak management
> [accordion] Focus on compliance with status filters
>
> Use status filters to focus on **Leaking** and **Delayed** items that require immediate attention for regulatory compliance.
> [accordion] Use grouping for analysis
>
> Group the table by **Component** or **Process Block** to identify patterns and recurring leak sources.
> [accordion] Monitor repair compliance
>
> Pay attention to the repair compliance column to track which leaks are approaching or have exceeded their repair deadlines.
## Related resources
* [Forms Overview](/use-sensorup/field-operations/forms/overview) — Understand form responses and data collection
* [Inspections Dashboard](/use-sensorup/field-operations/dashboards/inspections) — View OGI inspection issues
* [Issues Overview](/use-sensorup/field-operations/issues-tasks/overview) — Learn about managing follow-up issues
* [Vents Dashboard](/use-sensorup/field-operations/dashboards/vents) — Track venting devices
# Fugitive Emission Dashboards
Source: https://docs.sensorup.com/use-sensorup/field-operations/dashboards/overview
Monitor and manage fugitive emissions with dashboards covering OGI inspections, leaks, vents, and site check-ins.
# Overview
Fugitive Emission Dashboards provide a centralised view for monitoring and managing emissions data across your sites. The dashboards combine interactive maps with data tables, allowing you to visualise, filter, and act on fugitive emission records efficiently.
The dashboard is organised into four tabs, each focused on a specific aspect of fugitive emissions management:
* **Inspections** — View OGI inspection issues and track inspection progress
* **Leaks** — Monitor detected leaks and their repair status
* **Vents** — Track venting events and abnormal venting behaviour
* **Site Check-ins** — Review site survey data and environmental conditions
> [!NOTE]
>
> **Understanding the data sources:**
>
> * The **Inspections** tab displays [Issues](/use-sensorup/field-operations/issues-tasks/overview) — specifically OGI inspection issues
> * The **Leaks**, **Vents**, and **Site Check-ins** tabs display [Form Responses](/use-sensorup/field-operations/forms/overview) — structured data captured during field operations

## Key features
### View modes
Switch between different layouts to suit your workflow:
* **Split view** — Side-by-side map and table (default)
* **Map view** — Full-screen map visualisation with colour-coded markers
* **Table view** — Full-screen data grid with sorting and grouping
### Filtering and search
Quickly find the data you need:
* **Site filter** — Filter by specific sites
* **Date range** — Select from preset ranges (Last Week, Last Month, Last Quarter, etc.) or custom dates
* **Status filter** — Show or hide items by status using the visual legend
* **Spatial filter** — Filter by map viewport bounds
* **Search** — Search by Leak ID, Vent ID, or Site Name (varies by tab)
* **Historical data toggle** — Include or exclude historical data with import date tracking
### Data export
Export your data to Excel for reporting and analysis.
> [!WARNING]
>
> **Export availability:** Data export is currently available for the **Leaks** and **Vents** tabs only.
### Detail blade
Click on any item in the map or table to open a detail blade with:
* **Details tab** — View form response data and media attachments
* **History tab** — See a timeline of all related form submissions and status changes
## Dashboard tabs
> [card] [Inspections](/use-sensorup/field-operations/dashboards/inspections)
>
> View and manage OGI inspection issues, track field technician assignments, and monitor inspection progress.
> [card] [Leaks](/use-sensorup/field-operations/dashboards/leaks)
>
> Monitor detected leaks, track repair compliance, and manage leak data with filtering, editing, and export.
> [card] [Vents](/use-sensorup/field-operations/dashboards/vents)
>
> Track venting events, identify abnormal venting behaviour, and export vent data for reporting.
> [card] [Site Check-ins](/use-sensorup/field-operations/dashboards/site-check-ins)
>
> Review site survey data including environmental conditions and equipment states.
## Common workflows
### Reviewing inspection progress
1. Open the **Inspections** tab
2. Filter by date range or site
3. Use the status filter to focus on in-progress or completed inspections
4. Click an inspection to view details and linked leaks/vents
### Tracking leak repairs
1. Open the **Leaks** tab
2. Filter by status to view **Leaking** or **Delayed** items
3. Click a leak to view its details
4. Use follow-up actions to create repair or verification issues
## Permissions
Access to Fugitive Emission Dashboards is controlled by user roles:
| Role | Permissions |
| - | - |
| **Viewer** | View all dashboard data but cannot edit or export |
| **Editor** | View all data, edit records, and export data |
| **Administrator** | Full access including configuration |
| **Super Admin** | Full access across all features |
> [!NOTE]
>
> **Need more details?** See [User Roles and Permissions](/use-sensorup/user-management/User-roles-permissions) for complete information about role-based access control across all SensorUp features.
## Related resources
* [Issues Overview](/use-sensorup/field-operations/issues-tasks/overview) — Learn about creating and managing issues (displayed in the Inspections tab)
* [Forms Overview](/use-sensorup/field-operations/forms/overview) — Understand form responses (displayed in Leaks, Vents, and Site Check-ins tabs)
* [Outpost Mobile](/use-sensorup/outpost-mobile/overview) — Complete inspections and capture data on mobile devices
# Site Check-ins Dashboard
Source: https://docs.sensorup.com/use-sensorup/field-operations/dashboards/site-check-ins
View site survey data including environmental conditions and equipment states.
The Site Check-ins tab provides a view of all site survey data captured during inspections. Use this tab to review environmental conditions, equipment states, and other site-level information recorded by field technicians.
> [!NOTE]
>
> **What you'll learn:**
>
> * How to view and filter site check-in data
> * How to understand the data captured during site surveys
> * How to use the detail blade to review check-in details
> [!NOTE]
>
> **Data source:** This tab displays [Form Responses](/use-sensorup/field-operations/forms/overview) — specifically site check-in form responses captured at the start of inspections.
## Before you start
Ensure you have:
* Access to the Fugitive Emission Dashboards feature
* Viewer role or higher to view site check-in data
## Understanding the Site Check-ins tab
### Check-in statuses
Each site check-in has one of the following statuses:
| Status | Colour | Description |
| - | - | - |
| **Scheduled** | Blue | Check-in is planned but not yet completed |
| **In Progress** | Yellow | Field technician is actively completing the check-in |
| **Completed** | Green | Check-in has been finished |
### Environmental data
Site check-ins capture key environmental conditions that may affect inspection activities:
* **Temperature** — Ambient temperature at the site
* **Barometric Pressure** — Atmospheric pressure reading
* **Wind Speed** — Wind conditions during the survey
* **Weather Conditions** — General weather description
### Equipment states
Site check-ins document the operational status of key equipment:
* **Pneumatic Devices** — Status of pneumatic controllers and valves
* **Storage Tanks** — Tank levels and conditions
* **Instrument Air** — Status of instrument air systems
* **Power Supply** — Electrical power status
* **Shutdown Status** — Whether the site or equipment is shut down
* **Abandonment Status** — Whether the site has been abandoned
## Viewing and filtering site check-ins
**1. Open the Site Check-ins tab**
Navigate to the Fugitive Emission Dashboards and select the **Site Check-ins** tab from the tab bar.
**2. Choose your view mode**
Select the view that works best for your task:
* **Split view** — See both map and table side-by-side
* **Map view** — Full-screen map showing check-in locations
* **Table view** — Full-screen data grid with all columns
**3. Filter by site**
Use the **Site** dropdown to filter check-ins for a specific site, or clean up the filter to view all site check-ins.
**4. Set the date range**
Choose from preset date ranges or set a custom range. The date filter applies to the **Survey Date** field.
**5. Filter by status**
Click on status badges in the legend to show or hide check-ins by status.
## Using the detail blade
Click on any site check-in row or map marker to open the detail blade.
### Details tab
The Details tab displays:
* Survey metadata (date, status, field technician)
* Environmental readings (temperature, pressure, wind speed)
* Equipment status information
* Site conditions and notes
* Media attachments (photos from the survey)
## Understanding site check-in context
Site check-ins serve as the starting point for OGI inspections. The environmental and equipment data captured provides important context for:
* **Inspection validity** — Environmental conditions may affect detection equipment performance
* **Safety assessment** — Equipment states help identify potential hazards
* **Regulatory compliance** — Weather conditions may be required for compliance documentation
* **Operational context** — Shutdown or abandonment status affects how inspection results are interpreted
## Tips for using site check-in data
> [accordion] Review environmental conditions for inspection context
>
> When analysing leak or vent data, reference the corresponding site check-in to understand the environmental conditions during the inspection.
> [accordion] Monitor equipment status patterns
>
> Track equipment status over time to identify sites with recurring operational issues that may affect emissions.
> [accordion] Use with Inspections tab
>
> Cross-reference site check-ins with the Inspections tab to see the complete picture of each OGI survey.
## Related resources
* [Forms Overview](/use-sensorup/field-operations/forms/overview) — Understand form responses and data collection
* [Inspections Dashboard](/use-sensorup/field-operations/dashboards/inspections) — View OGI inspection issues
* [Leaks Dashboard](/use-sensorup/field-operations/dashboards/leaks) — Monitor detected leaks
* [Vents Dashboard](/use-sensorup/field-operations/dashboards/vents) — Track venting devices
# Vents Dashboard
Source: https://docs.sensorup.com/use-sensorup/field-operations/dashboards/vents
View and manage venting events with the Vents dashboard.
The Vents tab provides a view of all documented venting events across your sites. Use this tab to monitor vent status, identify abnormal venting behaviour, edit vent data, and export data for reporting.
> [!NOTE]
>
> **What you'll learn:**
>
> * How to view and filter vent data
> * How to use map and table views
> * How to edit vent records
> * How to export vent data
> [!NOTE]
>
> **Data source:** This tab displays [Form Responses](/use-sensorup/field-operations/forms/overview) — specifically Vent form responses captured during [inspections](/use-sensorup/field-operations/dashboards/inspections).
## Before you start
Ensure you have:
* Access to the Fugitive Emission Dashboards feature
* Viewer role or higher to view vent data
* Editor role or higher to edit records and export data
## Understanding the Vents tab
### Vent statuses
Each vent has one of the following statuses:
| Status | Colour | Description |
| - | - | - |
| **Abnormal** | Red | Venting behaviour is abnormal and requires attention |
| **Normal** | Green | Venting is within normal operating parameters |
| **Not Venting** | Purple | No active venting |
### Key data fields
The Vents table displays important information for each vent:
* **Vent ID** — Unique identifier for the vent record
* **Site** — The site where the vent is located
* **Detection Date** — When the vent was documented
* **Duration** — How long the venting event lasted
* **Emissions Rate** — Measured emissions rate
* **Volume** — Total volume of emissions
* **Component** — The equipment component
* **Process Block** — The process area within the site
* **Status** — Current vent status
## Viewing and filtering vents
**1. Open the Vents tab**
Navigate to the Fugitive Emission Dashboards and select the **Vents** tab from the tab bar.
**2. Choose your view mode**
Select the view that works best for your task:
* **Split view** — See both map and table side-by-side
* **Map view** — Full-screen map with colour-coded markers
* **Table view** — Full-screen data grid with all columns
**3. Filter by site**
Use the **Site** dropdown to filter vents for a specific site, or clean up the filter to view all vents.
**4. Set the date range**
Choose from preset date ranges or set a custom range. You can filter by:
* **Detected** — Filter by the detection date (when the vent was first documented)
* **Updated** — Filter by the last updated date (when the vent record was last modified)
**5. Filter by status**
Click on status badges in the legend to show or hide vents by status. This is useful for focusing on abnormal venting that requires attention.
**6. Search by Vent ID**
Use the search field to find a specific vent by its Vent ID.
**7. Toggle historical data**
Use the historical data toggle to include or exclude records imported from previous systems.
## Using map and table views
### Map view
The map displays vents as colour-coded markers based on their status. Interact with the map to:
* **Zoom and pan** to navigate to different areas
* **Click markers** to open the detail blade
* **Use spatial filtering** to filter by the current map viewport
### Table view
The table provides a detailed data grid with:
* **Sortable columns** — Click column headers to sort
* **Groupable columns** — Group by Site, Component, Process Block, or Status
* **Column visibility** — Show or hide columns as needed
* **Row highlighting** — Hover highlights corresponding map marker

## Using the detail blade
Click on any vent row or map marker to open the detail blade.

### Details tab
The Details tab displays:
* Vent metadata (ID, status, detection date)
* Form response data (emissions rate, duration, volume, component)
* Media attachments (photos, videos from field inspection)
### Single PDF export
You can export an individual vent record as a PDF from the detail blade.
**1. Open the detail blade**
Click on a vent to open its detail blade.
**2. Click the PDF button**
Click the **PDF** action button in the detail blade header.
**3. Download the file**
The PDF file will be generated and downloaded to your device.
### History tab
The History tab shows a timeline of:
* Initial documentation
* Status changes
* Related form submissions
## Editing vent data
Editors and administrators can update vent records directly from the dashboard.
**1. Open the detail blade**
Click on a vent to open its detail blade.
**2. Click Edit**
Click the **Edit** button to open the edit modal.
**3. Modify the data**
Update the form response fields as needed. Changes are validated before saving.
**4. Save changes**
Click **Save** to apply your changes. The dashboard will update to reflect the new data.

## Exporting vent data
Export filtered vent data to Excel for reporting and analysis.
**1. Apply filters**
Use the filtering tools to narrow down the data in the table you want to export.
**2. Click Export**
Click the **Export** button in the toolbar.
**3. Download the file**
Click **Export** to download the Excel file to your device.

### Batch PDF export
You can also export multiple vents as a single PDF for documentation or sharing.
**1. Click Export**
Click the **Export** button in the toolbar.
**2. Select Batch PDF**
Select the **Batch PDF** option to open the export modal.
**3. Customize export options**
Select the date range, site, and status filters you want to apply.
**4. Start the export**
Click the **Export** button to generate the PDF.
**5. Download the file**
Once complete, the combined PDF file downloads to your device.

## Tips for efficient vent management
> [accordion] Focus on abnormal venting
>
> Use status filters to focus on **Abnormal** items that require investigation or corrective action.
> [accordion] Use grouping for analysis
>
> Group the table by **Component** or **Process Block** to identify patterns in venting behaviour across your facility.
> [accordion] Monitor duration and volume
>
> Pay attention to duration and volume fields to identify significant venting events that may impact emissions reporting.
## Related resources
* [Forms Overview](/use-sensorup/field-operations/forms/overview) — Understand form responses and data collection
* [Inspections Dashboard](/use-sensorup/field-operations/dashboards/inspections) — View OGI inspection issues
* [Leaks Dashboard](/use-sensorup/field-operations/dashboards/leaks) — Monitor detected leaks
* [Site Check-ins Dashboard](/use-sensorup/field-operations/dashboards/site-check-ins) — Review site survey data
# Designing Custom Forms
Source: https://docs.sensorup.com/use-sensorup/field-operations/forms/create-and-manage-forms
Learn how to use SensorUp's Form Designer to create powerful, mobile-ready forms for inspections, leaks, repairs, and more.
## The Scenario
Custom forms are essential to capturing standardized field operations and office data—from leak reports to site check-ins and repairs. With SensorUp's Form Designer, you can create, edit, preview, and activate forms that are automatically made available for assignment through Issues. These forms can also dynamically pre-fill based on linked assets, saving field users and office staff time and ensuring consistent data.
Whether you're building a basic checklist or a complex form that adapts based on asset context, the Form Designer offers flexibility, structure, and full integration with the rest of the SensorUp platform.
> [!NOTE]
>
> **Who This Applies To:** Form builders, administrators, LDAR program managers\
> **Common Triggers:** New inspection round, new compliance requirement, updating old forms, or creating task-specific forms (e.g., leak repair)
## What You'll Accomplish
> [card] Primary Goal
>
> Build, edit, and publish a mobile-ready form linked to assets and ready for field operations and office assignment.
> [card] Success Metrics
>
> Accurate and complete field operations and office submissions, reduced manual data entry, and streamlined workflows through Issues.
## Step-by-Step Walkthrough
**1. Create a New Form**
* Click **"New Form"** in the Form Designer interface.
* Give your form a **clear name** (e.g., "Leak Repair Report").
* Select a **Parent Asset**:
* For general inspections (e.g., Leak Report), point to a **Site**.
* For follow-ups (e.g., Leak Repair), point to the specific **Emission Asset**.
* Optionally add a **Description** and assign a **Group** if your system uses multi-tenancy.
**2. Add and Configure Questions**
* Drag and drop question components onto the form canvas.
* Click any question node to open the **Configuration Panel** on the right.
* Edit properties like labels, required fields, default values, and visibility logic.
* Recommended: **Enable the Preview Panel** to see real-time changes and layout accuracy.
**Available Question Types:**
* Text Input, Textarea, Dropdown, Number
* Toggle Button, Checklist, Radio
* Barcode/QR Scanner, Photo with Annotation
* Video, File Upload, Geolocation
* Date & Time, Signature, Section Headings
**3. Enable Asset-Driven Prefill (Advanced)**
* Some questions (like dropdowns or text fields) can be dynamically **pre-filled** using linked asset properties.
* Example: A Leak Repair form can auto-populate **Component ID**, **Leak Status**, or **Location** from the linked Emission Asset.
* These dynamic values reduce field user and office staff effort and prevent data entry inconsistency.
**4. Save and Activate the Form**
* Click **Save** to preserve your draft.
* When ready, click **Activate** to publish the form.
* Activated forms become selectable within the **Issue Create** screen for assignment to technicians.
## Key Considerations
> [accordion] Important Factors
>
> * **Permissions:** Only users with Form Designer access can create or edit forms.
> * **Groups:** If multi-tenancy is enabled, ensure forms are scoped to the correct group.
> * **Form Activation:** Only activated forms appear in the Issue module.
> * **Asset Type Matching:** Choose the correct parent asset to ensure proper mobile context.
## Real-World Example
A program manager builds a new **Leak Repair** form linked to the **Emission Asset** type so that key fields like Component ID and Leak Status are pre-filled automatically. After adding required fields (repair method, photos, geolocation, signature), she activates the form and assigns it through an Issue. The technician completes it in Outpost with little manual input required.
> [!NOTE]
>
> **Result:** Repair tracking time reduced by 70%, with full compliance and photo verification per submission.
>
> **"It took 10 minutes to build the form—and now our entire repair workflow is standardized and traceable."**\
> *– LDAR Coordinator, Major Producer*
## Related resources
* [Forms Overview](/use-sensorup/field-operations/forms/overview) - Learn about forms and their role in field operations and office data collection
* [Tasks](/use-sensorup/field-operations/tasks/overview) - Create and manage tasks using forms
* [Issues](/use-sensorup/field-operations/issues-tasks/overview) - Organize and assign forms through issues
* [Results](/use-sensorup/field-operations/results/overview) - Review data captured from completed forms
* [Outpost Mobile](/use-sensorup/outpost-mobile/overview) - Complete forms on mobile devices
* [GraphQL API](/api/graphql/guides/field-service) - Access forms programmatically via API
# Form Overview
Source: https://docs.sensorup.com/use-sensorup/field-operations/forms/overview
Design customizable forms for structured data collection during field operations and office workflows.
# Overview
Forms are customizable configurations that define what data should be captured during a task. They act as blueprints for structured data collection, ensuring consistent documentation across both field operations and office workflows.
Forms do not exist in isolation—they are always part of an **Issue**. The Issue acts as the delivery mechanism, controlling the form’s assignment, severity, due date, and Issue description. An Issue can contain **one or more forms**, allowing teams to bundle related tasks such as a site check-in, leak report, and follow-up verification into a single workflow.
Whether forms are used during a field inspection or completed on a desktop review, each form captures a structured response that is stored for audit, compliance, and reporting.
**Key Features:**
* Extensive library of question types for maximum flexibility in data collection
* Validation rules to ensure data quality
* Reusable across multiple tasks and asset types
* Support for complex data structures and conditional logic
* Attachment support (photo, video, document upload)
* Context-aware prefilling
* Usable on both desktop and mobile (Outpost)
* Issued and assigned through the Issue module
## Supported Question Types
SensorUp’s Form Designer supports a wide variety of question types to match your data collection needs:
* **Text Input** — Single-line free text
* **Textarea** — Multi-line free text (notes, comments)
* **Dropdown** — Select one option from a list
* **Number** — Numeric-only fields
* **Toggle Button** — On/off or yes/no style input
* **Checklist** — Select multiple options
* **Radio** — Select one option from a set (visually grouped)
* **Scanner** — Scan and input barcodes or QR codes
* **Photo with Annotation** — Capture images and annotate in-app
* **Video** — Record and attach video evidence
* **Upload** — Attach external documents or files
* **Geolocation** — Automatically capture GPS coordinates
* **Date & Time** — Choose or timestamp date/time
* **Signature** — Capture digital signature input
* **Heading** — Add a visual break or section label (non-interactive)
These can be reordered, grouped, and configured using visibility conditions or prefilled with asset data.
## Common Use Cases
* **Leak Report** — Capture observations and measurements when a leak is detected, including photos, location, component ID, and emission estimates
* **Vent Report** — Document venting events with timing, volumes, and contextual information for regulatory tracking
* **Leak Repair & Verification** — Verify leak repairs with before/after photos, method used, technician signature, and timestamped resolution status
* **Asset Inventory** — Log and validate equipment and components during inventory tasks, with barcode scans and geotags
* **Site Inspection Report** — General site visit documentation, including inspection checklists, field notes, and status flags for follow-up actions
## Form Design Best Practices
When designing forms, consider:
* What data is essential for compliance, reporting, or analysis
* Ease of use for both mobile field users and desktop users
* Where prefills can reduce input burden and prevent errors
* Validation rules to ensure high-quality submissions
* Reusability across different tasks, workflows, and inspection types
## Forms and Tasks Within Issues
A **task** is an instance of a form in action. Tasks are always created and assigned through an **Issue**.
The Issue defines the overall work package:
* **Assignment** – Who the task is assigned to
* **Severity** – How urgent or critical the issue is
* **Due Date** – When the forms should be completed
* **Description** – Instructions or context for completing the task
* **Forms** – One or more forms to be filled out by the assignee
Once an issue is created, the assigned forms are made available to field technicians (via Outpost) or office staff (via desktop). Each completed form submission becomes a structured data record used for analysis, reporting, and audit tracking.
* A single form can power many tasks
* An Issue can include multiple forms (e.g., check-in + leak report + repair)
* Tasks can be completed on desktop or mobile
* Every submission creates a traceable response
## Permissions
Access to Forms is controlled by user roles. Understanding your role helps you know what actions you can take:
| Role | Permissions |
| - | - |
| **Viewer** | View all Forms but cannot create or modify |
| **Editor** | View all Forms but cannot create or modify |
| **Administrator** | View, create, update, and delete Forms |
| **Super Admin** | Full access across all features |
> [!NOTE]
>
> **Need more details?** See [User Roles and Permissions](/use-sensorup/user-management/User-roles-permissions) for complete information about role-based access control across all SensorUp features.
## Related resources
* [Tasks](/use-sensorup/field-operations/tasks/overview) - Create and manage tasks using form templates
* [Results](/use-sensorup/field-operations/results/overview) - Review data captured from completed tasks
* [Issues](/use-sensorup/field-operations/issues-tasks/overview) - Organize multiple tasks into issues
* [Outpost Mobile](/use-sensorup/outpost-mobile/overview) - Complete forms on mobile devices
* [GraphQL API](/api/graphql/guides/field-service) - Access forms via API
# Getting started with Work Management
Source: https://docs.sensorup.com/use-sensorup/field-operations/getting-started
Manage field operations and office workflows from detection through resolution with issues, tasks, forms, and results.
# Work Management
Work Management provides a complete workflow for managing field operations and office activities triggered by emission detections. The system connects issues, tasks, forms, and results to ensure structured data capture and accountability throughout the field operations and office workflow process.
## Core components
### Issues
Flyover detections automatically trigger follow-up issues that require field operations and office verification. Issues track the overall verification requirement and can be managed through the web interface.
**Key capabilities:**
* Automatically created from flyover detections
* Track verification status and priority
* Link to triggering observations
* Organize related field operations and office work
### Tasks
Issues are broken down into actionable tasks that field crews and office staff complete. Each task is an instance of a form template, meaning it uses a specific form structure for data collection. Tasks can be completed via the web interface or [Outpost Mobile](/use-sensorup/outpost-mobile/overview).
**Key capabilities:**
* Actionable tasks for field crews and office staff
* Instance of a form template
* Track completion status
* Assign to specific users or teams
* Complete via web or mobile app
* Multiple tasks can exist within a single issue
### Forms
Customizable templates that define what data should be captured during field operations and office work. Forms ensure consistent, structured data collection across all field and office activities.
**Key capabilities:**
* Design custom data collection templates
* Define field types and validation rules
* Reusable across multiple tasks
* Capture photos, measurements, and results
### Results created from task submission
When a task is completed by submitting a form, a structured result is captured. Each result not only documents the field operations and office work but also automatically creates a **Result** in SensorUp. Results represent detailed, timestamped records of what was detected, measured, or repaired (such as leaks, vents, or equipment status).
**Key capabilities:**
* Structured documentation of each completed task
* Automatically generate Results from task submissions
* Results include timestamp, location, detection method, and collected data
* Enable compliance tracking and audit-ready records
* Link results to the originating tasks and issues
## Outpost Mobile
Outpost Mobile is the companion app for Work Management, enabling field crews to complete tasks on iOS and Android devices. The mobile app provides offline access to asset information, forms, and task details.
[Learn more about Outpost Mobile →](/use-sensorup/outpost-mobile/overview)
## Workflow
1. **Detection** - Flyover observation identifies a potential emission
2. **Issue creation** - System automatically creates a follow-up issue
3. **Task creation** - Issue is broken down into multiple tasks, each using a form template
4. **Task assignment** - Tasks are assigned to field crews or office staff
5. **Field operations and office work** - Crews and staff complete tasks by filling out forms using Outpost Mobile or web interface
6. **Result generation** - Task completion creates a result with structured data
7. **New results** - Results can create new results (e.g., leak confirmations)
## Next steps
> [card] [Issues](/use-sensorup/field-operations/issues-tasks/overview)
>
> Learn how to manage issues that contain multiple tasks
> [card] [Tasks](/use-sensorup/field-operations/tasks/overview)
>
> Understand how tasks are instances of form templates
> [card] [Forms](/use-sensorup/field-operations/forms/overview)
>
> Design form templates for data collection
> [card] [Results](/use-sensorup/field-operations/results/overview)
>
> Review structured data from completed tasks
> [card] [Outpost Mobile](/use-sensorup/outpost-mobile/overview)
>
> Deploy the mobile app for field crews
> [card] [GraphQL API](/api/graphql/guides/field-service)
>
> Integrate field operations and office workflows via API
# Issues Overview
Source: https://docs.sensorup.com/use-sensorup/field-operations/issues-tasks/overview
Learn how to create, assign, and track Issues to manage field operations and office inspections and emission follow-ups.
Welcome to **Issues in SensorUp**—your central workspace for coordinating inspection work, tracking emissions-related tasks, and managing field operations and office workflows efficiently. In just a few minutes, you'll create your first Issue, assign it to a technician or office staff member, and track its lifecycle from creation to completion.
> [!NOTE]
>
> **Time Required:** 5–7 minutes\
> **What You'll Learn:**
>
> * How to create and assign an Issue
> * How to track tasks, comments, and data collection
> * How to collaborate between field operations and the office in real-time
> [!WARNING]
>
> **Common Pitfalls:**
>
> * Forgetting to assign an Issue—unassigned tickets won't appear in the field app
> * Missing due dates or severity—these help prioritize and schedule field operations and office work effectively
## Your First Steps
**1. Create a New Issue**
Click the **New Issue** button in the top left corner of Mission Control.
* Set the **Asset** the Issue relates to
* Provide a meaningful **title** and **description** (dynamic properties can be used)
* Choose a **due date** to enforce timely completion
* Select a **severity** level (Critical, High, Medium, Low) to prioritize
* **Assign** the Issue to a technician or team
Each created Issue will appear in the main list for tracking and management.

**2. Review and Manage Issue Details**
Clicking on any Issue in the list opens its detailed view:
* See the linked **Asset** and its metadata
* View and manage **instructions, tasks, and results**
* Use the **search and filter** tools to refine your view—filters are saved per user
* Monitor **modified data** streamed from field operations and office work in near real-time
* Add **comments** to coordinate with others

**3. Field Technician Responds via Outpost**
Assigned Issues appear in the **Outpost mobile app**.\
Technicians will:
* Complete a **Site Check-In form**
* Record results using **mobile forms** (including photos, geotags, severity, H₂S, etc.)
* Update the status to **In Progress** and complete tasks
* Add **comments** if needed for field-to-office communication
**4. Track, Review, and Close the Issue**
As the technician works, the Issue progresses:
* **Open** → **In Progress** → **Done**
* Field data is streamed live (or synced when back online)
* Office staff can **review, validate, or edit** data
* Once everything is confirmed, **mark the Issue as Closed**
> [!TIP]
>
> **You Did It!**\
> ✅ Created and assigned your first Issue\
> ✅ Tracked live progress and validated data from field operations and office work\
> ✅ Closed the Issue with full traceability
## Key Concepts Recap
> [!NOTE]
>
> ✅ **Issue (Ticket):** Structured task related to an Asset\
> ✅ **Lifecycle:** Open → In Progress → Done/Closed\
> ✅ **Asset Link:** Every Issue is tied to a site or equipment\
> ✅ **Collaboration:** Shared comments, data, and attachments across devices\
> ✅ **Visibility:** Accessible from web and mobile (SensorUp + Outpost)
## Additional Functionality
### Task and Procedure Tracking
Each Issue may include multiple **tasks or results** related to one site visit:
* Each task has a **lifecycle**: Open → In Progress → Done
* Task **status and details** can be viewed and edited by specialists in Mission Control
* All data collected is editable (except raw observation context)
### Comments and Communication
Use the **comments section** to:
* Capture unstructured insights from field operations and office work
* Communicate in real-time across teams
* All comments are instantly visible to users with access to that Issue

### Reopening and Reassignment
Closed Issues can be **reopened** by administrators in Mission Control:
* Reopened Issues are automatically **re-assigned** to the original user
* The Issue appears again in their mobile app for updates or corrections
### Deleting Issues
Users with delete permissions can remove Issues that are no longer needed.
To delete an Issue:
1. Open the Issue detail view
2. Click the **actions menu** (three dots icon) in the header
3. Select **Delete**
4. Review the confirmation dialog—it will display the Issue name and confirm that assets and statuses will not be affected
5. Click **Delete** to confirm
> [!NOTE]
>
> If you are deleting an Issue created by another user, the confirmation dialog will show the creator's name and their group (if different from yours).
> [!NOTE]
>
> The actions menu is only visible if you have manage permissions. If the delete option is disabled, hover over it to see the reason.
### Bulk Deleting Issues
You can select and delete multiple Issues at once from either the Issues list view or the Issues Map view.
To bulk delete Issues:
1. Select the Issues you want to delete by clicking the checkboxes next to each Issue in the list view, or by selecting markers in the Map view
2. A floating action bar appears at the bottom of the screen, showing the number of selected Issues
3. Click **Delete** in the floating action bar
4. Review the confirmation modal, which displays the total count of Issues to be deleted
5. Click **Delete** to confirm and start the bulk deletion job
> [!NOTE]
>
> The bulk delete option is only available to users with delete permissions. Viewers will not see the selection controls or the floating action bar.
> [!NOTE]
>
> If some of the selected Issues cannot be deleted, a modal will explain the reasons why those Issues are excluded from the bulk operation.
> [!NOTE]
>
> Sub-tasks belonging to deleted Issues are not automatically removed. You will need to manage sub-tasks separately if needed.
## Permissions
Access to Issues is controlled by user roles. Understanding your role helps you know what actions you can take:
| Role | Permissions |
| - | - |
| **Viewer** | View all Issues from groups they have access to, but cannot create, modify, or delete |
| **Editor** | View, create, and update Issues from groups they have access to; can only delete their own Issues |
| **Administrator** | View, create, update, and delete all Issues from groups they have access to |
| **Super Admin** | View, create, update, and delete all Issues |
> [!NOTE]
>
> **Need more details?** See [User Roles and Permissions](/use-sensorup/user-management/User-roles-permissions) for complete information about role-based access control across all SensorUp features.
## What's Next?
Now that you've created and completed your first Issue, you're ready to use advanced tools like triggered inspections, alarms, and multi-task workflows.
> [card] [Creating OGI Inspection Issues](/use-sensorup/connected-operations/issue-management/creating-ogi-inspection)
>
> Learn how to trigger and manage optical gas imaging inspections.
> [card] [Tasks](/use-sensorup/field-operations/tasks/overview)
>
> Learn how to create and manage tasks within issues.
> [card] [Forms](/use-sensorup/field-operations/forms/overview)
>
> Design form templates for tasks.
> [card] [Results](/use-sensorup/field-operations/results/overview)
>
> Review data from completed tasks.
> [card] [Outpost Mobile](/use-sensorup/outpost-mobile/overview)
>
> Complete tasks on mobile devices.
# Building a Complete Methane Management Program
Source: https://docs.sensorup.com/use-sensorup/getting-started/building-complete-methane-management-program
Transform scattered detection data into a systematic compliance and operational excellence program using integrated event management, quantification, analysis, and reporting capabilities.
## The Scenario
Your organization operates oil and gas facilities across multiple basins and receives methane detection alerts from various sources—satellites spot potential plumes during flyovers, continuous monitoring systems trigger alarms, drones capture detailed surveys, and field crews submit inspection reports. Each detection represents a potential environmental and compliance issue, but managing these scattered alerts across different systems creates operational chaos.
Without an integrated approach, your team struggles to distinguish genuine leaks requiring immediate field response from false positives or planned operational activities. Critical emissions might go unaddressed while resources are wasted investigating non-issues. Meanwhile, regulatory bodies expect comprehensive documentation showing exactly what happened, when it occurred, which equipment was involved, what actions were taken, and how volumes were calculated for emissions reporting.
Traditional approaches force you to juggle multiple disconnected systems—checking operational logs in one place, calculating emissions in spreadsheets, dispatching field crews through another system, and manually piecing together compliance reports from scattered data sources. This fragmented process leads to delayed responses, inaccurate volume calculations, incomplete audit trails, and difficulty meeting increasingly stringent environmental regulations.
> [!NOTE]
>
> **Who This Applies To:** Environmental managers, operations supervisors, compliance officers, and facility managers responsible for comprehensive methane management programs and regulatory compliance
> **Common Triggers:** Multiple detection sources generating alerts, upcoming regulatory reporting deadlines, audit preparation requirements, or the need to establish systematic LDAR (Leak Detection and Repair) program workflows
## What You'll Accomplish
> [card] Primary Goal
>
> Build a complete, defensible methane management program that transforms detection data into systematic compliance workflows with accurate quantification, complete audit trails, and measurable operational improvements
> [card] Success Metrics
>
> Reduce emission response time by 70%, achieve 100% audit-ready documentation, improve volume calculation accuracy by 60%, and establish measurable trends for continuous improvement
## Workflow Overview
The comprehensive methane management program follows an integrated approach that connects all aspects of emission lifecycle management:
```mermaid theme={null}
flowchart TD
A[Detection Alerts] --> B[Event Creation & Prioritization]
B --> C[Attribution & Quantification]
C --> D[Root Cause Investigation]
D --> E{Investigation Results}
E -->|Operational Activity| F[Document Context]
E -->|Equipment Issue| G[Field Response]
E -->|False Positive| H[Mark False Alarm]
F --> I[Accurate Quantification]
G --> J[Repair & Verification]
H --> K[Update Records]
I --> L[Compliance Reporting]
J --> M[Performance Analysis]
K --> N[System Learning]
L --> O[Regulatory Submission]
M --> P[Operational Insights]
N --> Q[Process Improvement]
style A fill:#ff6b6b
style O fill:#51cf66
style P fill:#51cf66
style Q fill:#51cf66
```
## Step-by-Step Walkthrough
**1. Establish Systematic Detection Management**
Transform incoming detection alerts from multiple sources into prioritized, actionable emission events using integrated event management capabilities.
**Setup Actions:**
* Configure automatic ingestion from all detection sources (satellites, drones, continuous monitoring, OGI inspections)
* Establish prioritization rules based on emission rates, asset criticality, and regulatory requirements
* Set up automated event creation and correlation to prevent duplicate investigations
* Configure status-based workflows to ensure no detection goes unmanaged
**Immediate Benefits:** Single dashboard view of all detections, automatic prioritization, elimination of duplicate work, clear audit trail from initial detection.
**2. Implement Accurate Attribution and Quantification**
Ensure each emission event is correctly attributed to specific assets and equipment with industry-standard volume calculations for regulatory compliance.
**Attribution Process:**
* Verify automatic asset attribution using proximity and operational context
* Correct attributions to specific equipment level (valve, compressor, tank) for targeted repairs
* Apply OGMP 2.0 source category classifications for regulatory compliance
* Document attribution decisions with explanatory context for audit defense
**Quantification Setup:**
* Configure Time and Rate Engine with detection method priorities (manual > VFB > CMS > OGI > drone > flyover > satellite)
* Establish no-detection integration rules for accurate time boundary determination
* Set up automatic timebounding using 90-day lookback periods and spatial proximity rules
* Enable confidence bound calculations for uncertainty quantification
**Outcome:** Accurate volume calculations with traceable methodology, proper regulatory categorization, equipment-specific attribution for targeted response.
**3. Deploy Systematic Root Cause Analysis**
Implement comprehensive investigation workflows that combine spatial, temporal, and operational context to determine emission sources and causes.
**Analysis Framework:**
* Use integrated map, timeline, and table views to understand emission event context
* Correlate detection timing with operational activities (maintenance, blowdowns, equipment startup)
* Examine spatial relationships between emissions and equipment locations
* Review operational "clues" including work orders, maintenance logs, and equipment status data
**Investigation Workflow:**
* Start with highest-impact events (largest volumes or critical assets)
* Look for patterns in timing, location, or equipment type
* Cross-reference with planned operational activities to distinguish fugitive from operational emissions
* Use wind direction and plume imagery to verify attribution accuracy
**Decision Points:** Confirmed equipment leak requiring repair, planned operational activity requiring documentation, or false positive requiring record correction.
**4. Execute Targeted Response Actions**
Based on investigation results, implement appropriate response workflows that ensure proper resolution and maintain comprehensive documentation.
**Equipment Leak Response:**
* Group related observations to prevent duplicate field dispatches
* Create structured follow-up requests (OGI inspection, field verification, repair work order)
* Track response through status-based workflows (Open → In Progress → Closed)
* Verify completion with follow-up surveys or equipment inspection
**Operational Activity Documentation:**
* Add manual observations with precise operational timing and emission rates
* Upload supporting documentation (work orders, maintenance logs, operational procedures)
* Integrate operational context with detection data for complete event narrative
* Classify as planned vs. unplanned emission for proper regulatory categorization
**False Positive Management:**
* Mark events as false alarms with clear reasoning and investigation notes
* Maintain complete audit trail of investigation process and decision rationale
* Use patterns to improve detection system calibration and reduce future false positives
**5. Generate Comprehensive Analytics and Insights**
Transform properly managed emission events into actionable insights for operational improvement and regulatory reporting.
**Summary Insights Analysis:**
* Identify top-emitting assets for targeted LDAR activities
* Analyze detection method effectiveness (satellite vs. drone vs. continuous monitoring)
* Categorize emissions by equipment type to focus maintenance programs
* Track event status distributions to measure response effectiveness
**Trend Analysis Implementation:**
* Monitor monthly emission trends to identify seasonal patterns or equipment degradation
* Track average response times to measure operational efficiency improvements
* Compare planned vs. unplanned emission ratios to assess operational control
* Measure before/after impacts of maintenance programs or process improvements
**Performance Optimization:**
* Use asset-level analysis to prioritize equipment replacement or upgrade decisions
* Optimize detection technology mix based on effectiveness analysis
* Adjust LDAR inspection frequencies based on historical failure patterns
* Identify operational improvements that reduce unplanned emissions
**6. Establish Continuous Compliance and Improvement**
Create systematic reporting workflows and performance monitoring that ensure ongoing regulatory compliance and operational excellence.
**Regulatory Reporting Automation:**
* Generate compliance reports with accurate volume calculations and complete audit trails
* Maintain OGMP 2.0 categorization and documentation standards
* Track regulatory deadlines and ensure timely submission with complete data packages
* Provide audit-ready documentation with traceable calculation methodologies
**Continuous Improvement Process:**
* Monthly performance review using trend analysis and summary insights
* Quarterly asset performance assessment to identify degrading equipment
* Annual LDAR program optimization based on detection effectiveness analysis
* Ongoing training updates based on investigation findings and best practice development
**Success Measurement:** Track key performance indicators including average response time, percentage of events reaching closed status, volume calculation accuracy compared to regulatory requirements, and audit readiness scores.
## Key Considerations
> [accordion] Technical Infrastructure Requirements
>
> **Data Integration Prerequisites:**
>
> * API connections or data feeds from all detection sources (satellite providers, drone operators, continuous monitoring systems)
> * Asset database integration with hierarchical facility and equipment information
> * Operational data feeds (work order systems, maintenance management, operational logs)
> * GIS/mapping data for spatial analysis and attribution validation
>
> **System Performance Factors:**
>
> * Processing capacity for real-time detection alert ingestion and correlation
> * Storage requirements for maintaining complete audit trails and historical analysis
> * User access management for multi-role teams (operations, compliance, field crews)
> * Integration capabilities with existing enterprise systems
> [accordion] Regulatory and Compliance Framework
>
> **Regulatory Alignment Requirements:**
>
> * OGMP 2.0 source category classification standards and documentation requirements
> * EPA and state regulatory reporting formats and timing requirements
> * Audit trail documentation standards for regulatory inspection readiness
> * Volume calculation methodology documentation and uncertainty quantification
>
> **Compliance Process Integration:**
>
> * Quarterly reporting workflow automation with data validation checkpoints
> * Annual compliance review processes with historical trend analysis
> * Audit preparation procedures with document retrieval and explanation capabilities
> * Regulatory update management to ensure ongoing compliance with changing requirements
> [accordion] Operational Integration and Change Management
>
> **Field Operations Coordination:**
>
> * Integration with existing dispatch and work order management systems
> * Field crew training on investigation protocols and response procedures
> * Mobile access capabilities for field verification and documentation
> * Communication protocols between operations, environmental, and compliance teams
>
> **Organizational Change Management:**
>
> * Role definition for emission event management responsibilities
> * Training programs for investigation techniques and system utilization
> * Performance metrics alignment with operational and environmental objectives
> * Continuous improvement processes based on lessons learned and best practices
## Common Variations
> [card] Multi-Basin Operations
>
> **Adaptation:** For organizations operating across multiple geographic regions, establish basin-specific analysis capabilities with centralized oversight, customized detection priorities based on regional equipment types, and compliance workflows aligned with varying regulatory requirements across jurisdictions.
> [card] High-Volume Continuous Operations
>
> **Adaptation:** For facilities with frequent planned emissions (refineries, chemical plants), implement enhanced operational activity integration with automatic correlation between work orders and detections, streamlined planned vs. unplanned classification workflows, and optimized volume calculations for complex operational scenarios.
> [card] Remote Asset Management
>
> **Adaptation:** For remote operations with limited field access, emphasize satellite and aerial detection methods, develop delayed verification protocols for inaccessible locations, and establish risk-based prioritization for remote response decisions with enhanced documentation requirements.
> [card] Regulatory-Heavy Environment
>
> **Adaptation:** For operations under strict regulatory oversight, implement enhanced documentation workflows with automatic audit trail generation, advanced uncertainty quantification for all volume calculations, and comprehensive compliance reporting automation with regulatory deadline tracking.
## Troubleshooting & Best Practices
> [card] Do This
>
> **Start with High-Impact Events**
>
> Focus initial implementation on largest emission events and most critical assets to demonstrate immediate value and build operational confidence in the systematic approach.
> [card] Do This
>
> **Establish Clear Attribution Standards**
>
> Define and document asset attribution protocols before full deployment to ensure consistent equipment-level attribution and support targeted maintenance responses.
> [card] Not That
>
> **Don't Skip Detection Source Integration**
>
> Incomplete integration of detection sources creates data gaps that compromise the systematic approach and reduce confidence in volume calculations and compliance reporting.
> [card] Not That
>
> **Don't Ignore Operational Context Integration**
>
> Without proper integration of operational data (work orders, maintenance logs), the system cannot distinguish planned from unplanned emissions, leading to inaccurate compliance categorization.
**Common Resolution Strategies:**
* **Volume Calculation Discrepancies**: Review Time and Rate Engine priority settings and no-detection integration rules; validate detection source calibration and uncertainty bounds
* **Attribution Accuracy Issues**: Check asset database completeness and spatial coordinate accuracy; review attribution distance thresholds and equipment location data
* **Investigation Efficiency Problems**: Examine operational data integration completeness; ensure proper training on investigation workflows and pattern recognition
* **Compliance Reporting Gaps**: Verify OGMP 2.0 categorization completeness; check regulatory deadline tracking and automated reporting workflows
## Real-World Example
MidContinental Energy operates 450 natural gas facilities across three states with operations ranging from wellhead gathering to processing plants. After implementing a comprehensive methane management program, they transformed their approach from reactive incident response to proactive emission management.
The first month revealed 23 high-priority emission events, with systematic investigation showing that 60% were attributed to planned maintenance activities that were poorly documented, 25% represented genuine equipment leaks requiring repair, and 15% were false positives from satellite detection calibration issues. Using integrated attribution and quantification capabilities, they corrected volume calculations that had been overestimating emissions by 40% in compliance reports.
Within six months, their average response time dropped from 5 days to 18 hours, they achieved 100% audit readiness with complete documentation trails, and trend analysis revealed seasonal patterns that enabled predictive maintenance scheduling. The systematic approach enabled them to demonstrate a 35% reduction in unplanned emissions through targeted equipment upgrades and operational procedure improvements.
> [!NOTE]
>
> **Result:** Achieved 70% reduction in response time, 100% audit readiness, 60% improvement in volume calculation accuracy, and \$2.3M in avoided penalties through proactive compliance management and operational optimization.
>
> **"This comprehensive approach transformed our environmental management from compliance burden to competitive advantage. We now identify and address issues before they become regulatory problems."**
> *- Environmental Director, MidContinental Energy*
## Related Use Cases
> [card] [Event Management Workflows](/use-sensorup/emission-operations/event-management/getting-started-with-event-management)
>
> Master the complete workflow for managing emission events from detection through resolution with integrated follow-up actions and status tracking.
> [card] [Root Cause Analysis Investigation](/use-sensorup/emission-operations/event-management/getting-started-root-cause-analysis)
>
> Learn systematic investigation techniques using spatial, temporal, and operational context to determine emission sources and implement targeted responses.
> [card] [Advanced Analytics and Insights](/use-sensorup/emission-operations/insights-and-analytics/getting-started-summary-insights)
>
> Transform properly managed emission data into actionable insights for asset prioritization, technology optimization, and operational improvement.
> [card] Regulatory Compliance Automation
>
> Establish automated compliance reporting workflows with accurate volume calculations and complete audit trail documentation for regulatory submission.
# Platform Overview
Source: https://docs.sensorup.com/use-sensorup/getting-started/platform-overview
Overview of SensorUp's platform capabilities and how each section connects to help you manage emissions, assets, and operations.
# Platform Overview
SensorUp provides a comprehensive platform for your methane management program. This guide summarizes each section of the platform and how they work together.
## Platform sections
### Assets
Manage your digital asset registry including facilities, equipment, wells, and components. Assets provide the foundation for contextualizing all observations and emissions data across the platform.
**Key capabilities:**
* Define and organize asset hierarchies
* Track asset lifecycle and status
* Link observations to specific assets
* Manage asset metadata and relationships
[Learn more about Assets →](/use-sensorup/assets/getting-started)
### Emission Operations
Transform detection data into systematic compliance workflows with integrated event management, quantification, analysis, and reporting capabilities.
**Key capabilities:**
* Manage emission events from detection through resolution
* Perform root cause analysis and attribution
* Calculate emission volumes with industry-standard methods
* Generate insights and analytics for operational improvement
[Learn more about Emission Operations →](/use-sensorup/getting-started/building-complete-methane-management-program)
### Work Management
Manage field operations and office workflows from detection through resolution. Issues, tasks, forms, and results work together to capture structured data during field operations and office work, with Outpost Mobile as the companion app for field crews.
**Key capabilities:**
* Track follow-up issues triggered by flyover detections
* Break down issues into actionable tasks
* Use customizable forms to capture structured field operations and office data
* Generate results documenting leaks, vents, and repairs
* Complete tasks via web or mobile app
[Learn more about Work Management →](/use-sensorup/field-operations/getting-started)
### Settings
Configure platform settings including unit conversions, user management, and system preferences.
**Key capabilities:**
* Manage unit conversion preferences
* Configure SQL viewer access
* Add and manage users
* Set user roles and permissions
[Learn more about Settings →](/use-sensorup/settings/unit-conversion-settings)
## How the sections connect
The following diagram shows how the core data entities in SensorUp connect to enable end-to-end methane management:
```mermaid theme={null}
flowchart TD
subgraph AssetsGroup["Assets"]
Assets[Assets]
end
subgraph EmissionOps["Emission Operations"]
Events["Emission Events"]
Observations["Emission Observations"]
end
subgraph Workflow["Work Management"]
Issues[Issues]
Tasks[Tasks]
Forms[Forms]
WorkflowResults[Results]
Outpost["Outpost (Mobile App)"]
end
subgraph ReportingGroup["Reporting"]
AnalysisEngine["Analysis Engine"]
Reconciliation["Reconciliation"]
end
Assets -->|are associated with| Observations
Events -->|groups| Observations
Events -->|feeds into| AnalysisEngine
AnalysisEngine -->|feeds into| Reconciliation
Observations -.->|Request triggers workflow starting with| Issues
Issues -->|is composed of| Tasks
Tasks -->|generates| WorkflowResults
Forms -->|is the template of| Tasks
Forms -->|is the schema of| WorkflowResults
WorkflowResults -.->|can be configured to create| Observations
Outpost -->|fulfills| Tasks
EmissionOps -->|fulfills| Tasks
```
### Understanding the workflow
1. **[Assets](/use-sensorup/assets/getting-started)** - Your facilities, wells, equipment, and components form the foundation of the platform
2. **[Emission Events](/use-sensorup/emission-operations/event-management/getting-started-with-event-management)** - Summarize one or more Emission Observations into a calculated duration, rate and total volume. Also used for user attribution and emissions resolution.
3. **[Emission Observations](/use-sensorup/getting-started/building-complete-methane-management-program)** - Individual detections from flyovers or OGI surveys are linked to assets and grouped into events
4. **[Issues](/use-sensorup/field-operations/issues-tasks/overview)** - A request from an emission observation triggers a workflow starting with an issue that requires field operations and office verification
* **Tasks** - Issues are broken down into actionable tasks completed via web or [Outpost Mobile](/use-sensorup/outpost-mobile/overview)
* **Results** - Task completion generates results that document leaks, vents, or repairs, and can be configured to create new emission observations
5. **[Forms](/use-sensorup/field-operations/forms/overview)** - Customizable templates that define the structure of tasks and the schema for results
## Next steps
> [card] [Assets](/use-sensorup/assets/getting-started)
>
> Start by setting up your asset registry
> [card] [Emission Operations](/use-sensorup/getting-started/building-complete-methane-management-program)
>
> Build your methane management program
> [card] [Work Management](/use-sensorup/field-operations/getting-started)
>
> Manage field operations and office workflows
> [card] [API & MCP](/api/graphql/overview)
>
> Integrate with SensorUp APIs
# How to Install Outpost (Android)
Source: https://docs.sensorup.com/use-sensorup/outpost-mobile/android-install
Step-by-step instructions for installing and signing in to the Outpost app by SensorUp using Android phones and tablets.
# How to Install Outpost (Android)
This guide walks you through the installation and sign-in process for the **Outpost** app by SensorUp on Android mobile phones and tablets.

***
> [!NOTE]
>
> **Prerequisites**
>
> * You must have a SensorUp user account (email and password).
> * You'll need your organization's **Server URL**, which you'll use to log in.
***
### Sign in using the following details
* Use your **Server URL**, **email**, and **password** to log in.
***
### Android Installation Instructions
1. Open the [**Google Play Store**](https://play.google.com/store/apps/details?id=com.sensorup.sensorhub\&pcampaignid=web_share\&pli=1) on your Android device.
2. Search for **SensorUp Outpost**.
3. Tap **Install** to download the app.
4. Once installed, tap **Open** to launch the app.
5. On the first sign-in screen:
* Enter your **Environment URL** (e.g., `https://yourcompany.sensorup.com`) and tap **Next**.
* Enter your **account email address** and **password**, then tap **Sign In**.
6. If you've set up **Two-Factor Authentication**, enter the verification code.
* If not, you'll be prompted to set it up.
* You can optionally check **"Don't ask me again on this device"** before entering the code.
***
## First-Time Access
If you're a new user:
* Ensure you've received an invitation**email** from SensorUp.
* Follow the link in the email to activate your account and set your password.
* Return to the app and sign in using the credentials you just created.
***
## Grant Permissions
Follow these steps to ensure the app functions properly:
1. When prompted, tap **Allow Location**.
2. You'll be redirected to **Outpost App Info** in your Android settings.
3. Tap **Permissions** > **Location** > **Allow all the time**.
4. Use the top-left **Back arrow** to return step-by-step back to Outpost.
5. If needed, manually re-open the Outpost app from your app drawer.
6. On the **Additional Permissions** screen, allow the following:
| Permission | Recommended Option |
| - | - |
| Camera & Video | While using the app |
| Notifications | Allow |
| Photos and Media Access | Allow all |
***
## Downloading Resources
* After signing in, the app will begin downloading resources required for initial setup.
* This may take a few moments for first-time users.
***
## You're All Set!
You're now ready to start using **SensorUp Outpost** on your Android device to manage inspections, tasks, and emissions workflows.
# How to Install Outpost (iOS)
Source: https://docs.sensorup.com/use-sensorup/outpost-mobile/ios-install
Step-by-step guide to installing and signing in to the Outpost app by SensorUp on iPhones and iPads.
# How to Install Outpost (iOS)
This guide will walk you through the installation and sign-in process for the **Outpost app** on any iOS mobile device or iPad.

> [!NOTE]
>
> **Prerequisites**
>
> * You must have an existing SensorUp account (email and password).
> * You'll also need your organization's **Server URL**, which is used to sign in to the app.
***
## Sign in with the following information
* Use your **Server URL**, **email**, and **password** to log in.
***
## Apple iOS Installation Instructions
1. Open the [**Apple App Store**](https://apps.apple.com/ca/app/outpost-by-sensorup/id6443835566) on your iOS device.
2. Search for **Outpost by SensorUp**.
3. Tap **Install** to download the app.
4. Once installed, tap **Open** to launch the app.
5. On the Sign In screen:
* Enter your **Environment URL** (e.g., `https://yourcompany.sensorup.com`) and tap **Next**.
* Enter your **email address** and **password**, then tap **Sign In**.
6. If you've already set up **Two-Factor Authentication**, you'll be prompted to enter your code.
* If not, you'll be guided to set it up for added security.
* Optionally, select **"Don't ask me again on this device"** on trusted devices.
7. Tap **Sign In** to access the app.
***
## First-Time Access
If you're a new user:
* Look for the **invite email** from SensorUp.
* Click the link in the invite to set up your account and password.
* Then return to the app and sign in using the credentials you created.
***
## Grant Permissions
When prompted, grant the following permissions to ensure full app functionality:
| Permission | Recommended Option | Why It's Needed |
| - | - | - |
| Notifications | Allow | Stay updated on assigned tasks and alerts |
| Location | Allow While Using App | Ensures location-based issues and workflows function |
| | If prompted again: Keep Only While Using | |
| Photos, Media, and Files | Allow | Enables file uploads for forms and reports |
***
## Downloading Resources
* After logging in, the app will automatically download the required resources.
* This may take a few moments during the initial setup.
***
## You're All Set!
You're now ready to start using **SensorUp Outpost** for managing inspections, tasks, and workflows in the field.
# Getting Started with Outpost Mobile Field App
Source: https://docs.sensorup.com/use-sensorup/outpost-mobile/overview
Use Outpost to complete inspections, track issues, and collect data—even while offline.


## Welcome!
Welcome to **Outpost**, your mobile companion for LDAR inspections and field operations. Whether you're at a remote site or working in a connected environment, Outpost makes it easy to manage issues, perform inspections, collect data, and stay compliant. This guide will walk you through installing the app, exploring the core tabs, and completing your first inspection.
> [!NOTE]
>
> **Time Required:** 5–10 minutes\
> **What You'll Learn:**
>
> * How to navigate the Outpost mobile app
> * How to complete an OGI Inspection with the required forms
> * How to work offline and sync data later
> [!WARNING]
>
> **Common Pitfalls:**
>
> * Skipping required forms (e.g. Site Check-In) before submitting results
> * Not syncing data after working offline—wait for confirmation before exiting the app
## Your First Steps
**1. Install Outpost Mobile App**
Outpost is available on both [**iOS**](/use-sensorup/outpost-mobile/ios-install) and [**Android**](/use-sensorup/outpost-mobile/android-install) devices.
* Search for **SensorUp Outpost** in the App Store or Google Play
* Install the app and log in with your credentials
* Make sure to allow location access and camera permissions
**2. Explore the Main Tabs**
Outpost has four main tabs:
* **Maps:** View all leaks, vents, and site information plotted on a map. Tap on any item to view or take action. Use search to locate specific leaks or sites.
* **Issues:** Manage your assigned tickets. Sort by due date, proximity, or update time. Filter by status, site, or customer (if multi-tenancy is enabled). You can also **search or create new issues** directly.
* **Alerts:** Review notifications and app messages.
* **More:** Adjust settings and view app information.

**3. Work an Assigned Issue**
Tap on any Issue in the **Issues** tab to open its details:
* **Site Summary Widget:** Shows all current and historical leaks and vents with their status (Leaking, Delayed Repair, Repaired, Vented).
* **Issue Info:** View description, due date, route link (opens Google/Apple Maps), and assignment details.
* **Forms:** Issues may have **Required** and **Optional** forms.
* Required forms (like Site Check-In) must be completed before optional results.
* Tap the **+ button** (iOS top-left or Android Results section) to add results (e.g. Leak, Repair, Re-Inspection, Vent).
* Select a **form**, then choose a **sub-location or Floc**.

**4. Collect Data and Submit**
Complete and submit your forms:
* Add **photos**, use **annotation tools**, and validate tags to prevent duplicates
* Dynamic **prefill options** help reduce manual entry
* You can **Save & Close** to return later or **Submit** to finalize (this creates the leak or observation record)
When done with all tasks:
* Tap **Submit Issue** to close it
* Optionally, add a **comment** at the bottom of the issue for coordination
> [!TIP]
>
> **You Did It!**\
> ✅ Logged into Outpost and explored the app\
> ✅ Completed a full Issue workflow with forms and results\
> ✅ Submitted your data and closed the Issue
## Offline Support
Outpost is fully **offline-ready**. If you're visiting a remote site with no connectivity:
* The app automatically switches to offline mode
* All data is saved locally
* Once you're back online, Outpost will **automatically sync** your data
* You'll see confirmation once syncing is complete
> [!NOTE]
>
> No need to worry—your work is always saved, even in the field.
## What's Next?
Now that you've completed your first field inspection using Outpost, you're ready to explore even more powerful features like form customization, tag scanning, and dynamic workflows.
> [card] [Using Custom Forms in Outpost](/docs/outpost-custom-forms)
>
> Learn how to use pre-configured forms for different inspection types.
> [card] [Creating New Issues in the Field](/docs/creating-issues-mobile)
>
> Learn how field techs can generate new tickets on the go.
# How to Query Datasets with SQL Viewer
Source: https://docs.sensorup.com/use-sensorup/settings/cam-sql-viewer
Learn how to explore, query, and export data from your datasets using the SQL Viewer's interactive interface
## What You'll Learn
In this guide, you'll learn how to query and analyze your data using the SQL Viewer. By the end, you'll be able to:
> [!TIP]
>
> * Select and explore available datasets
> * Write SQL queries using the editor or visual builder
> * Execute queries and view results in an interactive table
> * Export large datasets in multiple formats
## Before You Start
> [!NOTE]
>
> **Prerequisites:** Observer-level access or higher to view and query datasets
>
> **Estimated Time:** 10-15 minutes
>
> **Difficulty Level:** Intermediate to Advanced
> [!NOTE]
>
> If you're unsure which dataset contains the information you need, contact your Customer Success Manager for guidance before proceeding.
## Understanding the SQL Viewer Interface
The SQL Viewer provides a workspace divided into three main sections:
1. **Dataset Browser** (Left Panel) - Browse and select from available datasets
2. **Query Editor** (Top Right Panel) - Write and build your SQL queries
3. **Results Viewer** (Bottom Right Panel) - View and export query results

## Step-by-Step Instructions
**1. Navigate to the SQL Viewer**
From the main navigation menu, locate and click on **Settings**, then select **CAM SQL Viewer**.
You'll see the three-panel workspace with the dataset browser on the left and the query editor on the right.
**2. Select a Dataset**
In the **left panel**, browse the list of available datasets. You can:
* **Search by name**: Use the search box at the top to filter datasets
* **Browse by group**: Datasets are organized into groups using expandable sections
* **Review status**: Look for error badges that indicate dataset issues
Click on a dataset to select it. Once selected:
* The dataset name will be highlighted
* The schema (list of columns) will appear below the dataset list
* The query editor will be ready for use

**3. Review the Dataset Schema**
After selecting a dataset, review the **column list** that appears in the left panel. This shows:
* **Column names**: The fields available in your dataset
* **Data types**: Whether each column contains text, numbers, dates, or other data types
> [!TIP]
>
> You can click on column checkboxes to automatically add them to your SELECT clause in the query editor.
**4. Build Your Query**
In the **query editor** (top right panel), you have multiple options for building your query:
**Option 1: Text Editor**
* Write your SQL query directly in the text field
* Use autocomplete by pressing `Ctrl+Space` or typing 2+ characters
* Click the **Format** button to clean up your SQL formatting
**Option 2: Visual Builder**
* Switch to the **Visual Builder** tab for a no-code interface
* Use drag-and-drop controls to build your query
* The SQL is automatically generated as you build
**Option 3: Query Cookbook**
* Click the **Help** button (?) to open the Query Cookbook
* Browse 20+ pre-built query templates
* Click any template to insert it into your editor
* Modify the template to match your specific needs
**Generate a report of closed emissions from the previous quarter that have been processed through emission operations, including all resolution details:**
```sql Example: Previous Quarter Closed Emissions theme={null}
SELECT *
FROM MainTable
WHERE startTime::DATE >= DATE_TRUNC('quarter', CURRENT_DATE - INTERVAL '3 months')
AND startTime::DATE < DATE_TRUNC('quarter', CURRENT_DATE)
AND status = 'CLOSED'
LIMIT 100
```
**View all emissions with OPEN or IN PROGRESS status that require resolution by the emission operations team. Use this query to track your team's pending work items:**
```sql Example: Pending Emissions Pending Resolution theme={null}
SELECT *
FROM MainTable
WHERE status IN ('OPEN', 'IN_PROGRESS')
ORDER BY startTime DESC
LIMIT 100
```

**5. Choose Your Query Mode**
Before executing your query, select the appropriate execution mode and output format:
**Execution Mode:**
* **Standard Mode** (default): Best for testing queries. Returns results in 30 seconds or times out.
* **Async Mode** (toggle on): For large or complex queries that take longer than 30 seconds. Results are processed in the background.
**Output Format:**
* **Table View** (ARRAY): Displays up to 1,000 rows in an interactive table
* **CSV Export**: Generates a comma-separated values file for unlimited rows
* **Parquet Export**: Creates a columnar format file optimized for analytics
> [!WARNING]
>
> **Best Practice:** Always test your query in Standard Mode with Table View first to validate your SQL syntax. Once confirmed, switch to Async Mode with CSV/Parquet for large datasets.
**6. Execute the Query**
Click the **Run Query** button (or press `Ctrl+Enter`) to execute your query.
You'll see a progress indicator while the query runs. You can:
* **Cancel** the query at any time by clicking the Cancel button
* **Monitor** the status in the results panel
**7. View and Export Results**
**For Standard Mode (Table View):**
* Results appear in the interactive table below the query editor
* Sort columns by clicking on column headers
* Filter data using the column menu options
* Export visible results using the export buttons
**For Async Mode (CSV/Parquet):**
* The file will be prepared in the background
* When ready, your browser will automatically download the file
* Open the file in Excel, a text editor, or your preferred analytics tool
* The results panel will also load a preview of the first 1,000 rows

> [!TIP]
>
> **Success!** You've successfully queried your dataset. Your results are now ready for analysis.
## Query Execution Modes Explained
> [card] Standard Mode
>
> **When to use:**
>
> * Writing and testing new queries
> * Working with smaller datasets
> * Need immediate feedback
>
> **Limitations:**
>
> * 30-second timeout
> * Up to 1,000 rows in table view
> [card] Async Mode
>
> **When to use:**
>
> * Large datasets with millions of rows
> * Complex queries with joins or aggregations
> * Exporting complete datasets
>
> **Behavior:**
>
> * No timeout limit
> * Results processed in background
> * Automatic file download when ready
## Best Practices
> [card] Do This
>
> **Action:** Start with `LIMIT 100` when testing queries
>
> **Why:** This helps you verify your query logic quickly without processing large amounts of data. Remove the limit once you're confident in your query.
> [card] Not That
>
> **Action:** Running queries without a LIMIT on large datasets in Standard Mode
>
> **Why:** This can cause timeouts and slow performance. Always test with a limit first, then use Async Mode for full datasets.
> [card] Do This
>
> **Action:** Use the Query Cookbook templates as starting points
>
> **Why:** Templates are pre-tested and follow SQL best practices. They save time and help you learn effective query patterns.
> [card] Not That
>
> **Action:** Writing complex queries from scratch without reference
>
> **Why:** You might miss optimizations or make syntax errors. Leverage the cookbook for proven patterns.
## Common Issues & Solutions
> [accordion] My query is timing out after 30 seconds
>
> **Solution:** This is expected behavior in Standard Mode for large or complex queries.
>
> **Steps to resolve:**
>
> 1. Add a `LIMIT` clause to test your query with fewer rows
> 2. Once your query works, toggle on **Async Mode**
> 3. Select CSV or Parquet as your output format
> 4. Run the query again - it will process in the background without timeout limits
> [accordion] I see an error: 'Column not found' or 'Syntax error'
>
> **Solution:** This indicates a SQL syntax issue or incorrect column name.
>
> **Steps to resolve:**
>
> 1. Check the schema panel on the left to verify correct column names
> 2. Column names with spaces or special characters need double quotes: `"Column Name"`
> 3. Use the **Format** button to clean up your SQL
> 4. Try clicking column checkboxes to auto-generate proper column references
> 5. Review the Query Cookbook for syntax examples
> [accordion] The results table only shows 1,000 rows but I need all my data
>
> **Solution:** The table view is limited to 1,000 rows for browser performance.
>
> **Steps to resolve:**
>
> 1. Change the output format to **CSV** or **Parquet**
> 2. Toggle on **Async Mode** if you expect a large result set
> 3. Run your query
> 4. The complete file will be downloaded to your computer with all rows
> [accordion] My dataset shows an error badge - what does this mean?
>
> **Solution:** Error badges indicate issues with the dataset.
>
> **Badge meanings:**
>
> * **Red badge**: Connection error or dataset not found - contact support
> * **Yellow badge**: Previous query error - try selecting the dataset again to clear the error
>
> If the error persists after reselecting, contact your administrator.
> [accordion] Autocomplete isn't appearing when I type
>
> **Solution:** Autocomplete requires certain conditions to activate.
>
> **Requirements:**
>
> 1. The query editor must be focused (cursor blinking)
> 2. You've typed at least 2 characters
> 3. A dataset is selected (for column suggestions)
>
> **Manual trigger:** Press `Ctrl+Space` to manually open autocomplete at any time.
> [accordion] Can I save my queries for later use?
>
> **Solution:** Query history is tracked during your current session.
>
> **To reuse queries:**
>
> 1. Click the **History** button in the query editor toolbar
>
> 2. Select from your recent queries (up to 50 stored)
>
> 3. The query will be loaded into the editor
>
> > [!NOTE]
> >
> > Query history is stored in your browser and will be cleared when you refresh the page. For important queries, save them in a text file or document.
## Advanced Tips
> [accordion] Using Time-Based Filters Effectively
>
> When working with time-series data, use these SQL patterns for better performance:
>
> **Last 7 days:**
>
> ```sql theme={null}
> WHERE observed_at >= now() - INTERVAL 7 DAY
> ```
>
> **Specific date range:**
>
> ```sql theme={null}
> WHERE observed_at BETWEEN '2024-01-01' AND '2024-01-31'
> ```
>
> **Current month:**
>
> ```sql theme={null}
> WHERE date_trunc('month', observed_at) = date_trunc('month', now())
> ```
> [accordion] Working with Large Result Sets
>
> For queries returning millions of rows:
>
> 1. **Use Parquet format** instead of CSV for better compression and faster downloads
> 2. **Enable Async Mode** to avoid timeout issues
> 3. **Add indexes to your WHERE clause** - filter on timestamp or ID columns when possible
> 4. **Aggregate when possible** - use `GROUP BY` to summarize data instead of exporting raw rows
> [accordion] Building Efficient Aggregation Queries
>
> When summarizing data, follow these patterns:
>
> **Daily averages:**
>
> ```sql theme={null}
> SELECT date_trunc('day', observed_at) AS day,
> AVG(value) AS daily_average
> FROM MainTable
> WHERE observed_at >= now() - INTERVAL 30 DAY
> GROUP BY day
> ORDER BY day
> ```
>
> **Top 10 by metric:**
>
> ```sql theme={null}
> SELECT sensor_id,
> AVG(value) AS avg_value
> FROM MainTable
> WHERE observed_at >= now() - INTERVAL 7 DAY
> GROUP BY sensor_id
> ORDER BY avg_value DESC
> LIMIT 10
> ```
> [accordion] Interactive Schema Panel Shortcuts
>
> The schema panel offers quick ways to build queries:
>
> * **Click individual columns** to add/remove them from your SELECT clause
> * **Click "Select All"** to add all columns at once
> * **Columns with special characters** are automatically quoted correctly
> * **The query updates in real-time** as you click checkboxes
>
> This is the fastest way to build initial SELECT statements without typing.
## Supported SQL Features
The SQL Viewer uses DuckDB SQL dialect, which supports:
* **Standard SQL operations**: SELECT, WHERE, GROUP BY, ORDER BY, LIMIT
* **Aggregations**: COUNT, SUM, AVG, MIN, MAX, percentiles
* **Time functions**: Date arithmetic, intervals, time zones
* **Window functions**: Running totals, moving averages, rankings
* **String operations**: Pattern matching, concatenation, formatting
* **Math operations**: Basic arithmetic, rounding, statistical functions
> [!TIP]
>
> For complex SQL syntax questions, use the Query Cookbook's examples or consult the DuckDB SQL documentation for advanced features.
# Unit Conversion Settings
Source: https://docs.sensorup.com/use-sensorup/settings/unit-conversion-settings
Unit conversion provides the flexibility to customize how emission data is displayed and calculated throughout the application. You can set your preferred measurement units for emission rates and volumes to match your personal needs.
## Configuring Your Unit Preferences
You can set default units that will be applied to all emission data you see. Your preferences are saved to your profile and will remain consistent every time you log in.
1. Navigate to your Avatar in the **bottom left corner** of the application.
2. Click on **My Profile**.
3. In the settings panel, locate the **Units / Emission Events** section.
4. Configure your units:
* **Measurement Type**: Select whether you want to view emissions by Mass (e.g., $kg$) or Volume (e.g., $m^3$).
* **Unit System**: Choose your preferred system (e.g., Metric or Imperial).
* **Time Unit for Rate**: Select the time basis for emission rates (e.g., per hour, per day, per minute).
* **Methane Density Standard**: Choose the scientific standard for methane density calculations from the dropdown menu.
5. Click **Save** to apply your changes.
> [!NOTE]
>
> These settings only change **your personal view** of the data. They do not change the settings or the data view for anyone else in your organization.
## Conversion Standards
The application supports the following standards:
| Standard | Standard Conditions | Methane ($CH_4$) Density |
| :- | :- | :- |
| **IUPAC** | $0^{\circ}C$ (273.15 K) and 100 kPa (1 bar) | $0.7082593 \ kg/m^3$ |
| **NIST** | $0^{\circ}C$ (273.15 K) and 101.325 kPa (1 atm) | $0.71766905 \ kg/m^3$ |
| **EPA** | $20^{\circ}C$ (293.15 K) and 101.325 kPa | $0.656 \ kg/m^3$ |
| **EPA / AGA / ISO** | $15^{\circ}C$ (288.15 K) and 101.325 kPa | $0.6799 \ kg/m^3$ |
| **BC-ER** | $15^{\circ}C$ (288.15 K) and 101.325 kPa | $0.6785 \ kg/m^3$ |
> [!WARNING]
>
> All data in our system is ingested and stored as Mass ($kg$). This means there may have already been a conversion from Volume to Mass before the data was imported.
The reason we have this option to convert to Volume is to improve communication between teams. For example, it allows Air Quality users to share findings with Operators using volumetric units, which may better match the Operators' context and equipment readings.
## Where Your Settings Apply
Once you save your preferences, all data related to emission events will automatically be displayed in your chosen units. This affects numerical values everywhere you see them, including:
* **Emission Event Lists**: Tables and lists showing multiple emissions.
* **Detail Panels**: The detailed view for a single emission event.
* **Analytics & Reports**: All charts, graphs, and reports you view or generate.
## Benefits of Custom Units
#### For Individual Users
* **Consistency**: View all data in the units you are most comfortable with.
* **Efficiency**: Eliminate the need for manual conversions and external calculators.
* **Clarity**: Reduce confusion and potential errors from interpreting mixed unit displays.
## Tips & Best Practices
* **Choose the Right Standard**: Before analyzing data, confirm you have selected the methane density standard that matches your project or regulatory requirements.
* **Verify for Critical Reports**: When preparing data for compliance or critical reports, always double-check that the selected units and standards are correct.
* **Align With Your Team**: Coordinate with your team members to agree on a set of preferred units to ensure seamless collaboration.
## FAQ
**Q: Can I set default units for my entire organization or team?**
A: Currently, unit preferences are set on an individual user basis and do not apply to your entire organization. However, we are always looking for ways to improve collaboration. If having organization-wide default settings would be useful for your team, please share this feedback with your designated **Customer Success contact**.
**Q: Why does my emission data look different after I changed my settings?**
A: This is expected behavior. Each methane density standard uses different temperature and pressure values, which results in a different calculated emission mass or volume. Ensure you have selected the correct standard for your needs.
**Q: Some parts of the application are still showing the old units.**
A: Try refreshing the page. If the issue persists, logging out and logging back in will ensure that your new preferences are applied to all components across the application.
***
## Support & Feedback
For any questions, support needs, or feedback regarding unit conversion, please reach out to your designated **Customer Success contact**.
# User Roles and Permissions
Source: https://docs.sensorup.com/use-sensorup/user-management/User-roles-permissions
Learn about the different user roles in SensorUp and what actions each role can perform across sections like Emissions, Issues, Reconcile, and more.
# User Roles and Permissions
SensorUp uses role-based access control to manage what users can see and do across the app. This guide outlines the available roles and their permissions.
## Roles Overview
| Role | Description |
| - | - |
| Viewer | Can view all data but cannot take any actions. |
| Editor | Can view all data and take limited actions in specific sections. |
| Administrator | Can view all data and manage content across most sections. |
| Super Admin | Full access across all features. Only available to internal SensorUp staff. |
***
## Permissions by Section
| Section | Viewer | Editor | Administrator | Super Admin |
| - | - | - | - | - |
| [Emissions](/use-sensorup/emission-operations/event-management/getting-started-with-event-management) | View only | Create, Update | Create, Update | Create, Update |
| [Issues](/use-sensorup/field-operations/issues-tasks/overview) | View only | Create, Update | Create, Update | Create, Update |
| [Forms](/use-sensorup/field-operations/forms/overview) | View only | View only | Create, Update, Delete | Create, Update, Delete |
| OGMP2 | View only | View only | View only | View only |
| Explore Maps | View public only | View public + Manage own | Create, Update, Delete | Create, Update, Delete |
| [Assets](/use-sensorup/assets/getting-started) | View only | View + Manage own | Create, Update, Delete (Full CRUD) | Create, Update, Delete (Full CRUD) |
| [User Management](/use-sensorup/user-management/adding-new-user) | View group | View group | Create, Read, Update, Delete users in their group and child groups | Create, Read, Update, Delete all users in their group and child groups (including other Super Admins) |
| My Profile | Update | Update | Update | Update |
***
> **Note:** Super Admins are internal SensorUp users only and cannot be assigned to external organizations.
# Creating and Accepting an Invite in the SensorUp Platform
Source: https://docs.sensorup.com/use-sensorup/user-management/adding-new-user
Learn how to invite a new user to SensorUp and how invitees can securely create their accounts.
## Welcome!
SensorUp makes it simple and secure to add new users to your workspace. Whether you're managing field technicians, analysts, or admins, this guide will walk you through inviting a new user—and show them how to accept the invite and log in for the first time.
> [!NOTE]
>
> **Time Required:** 5 minutes\
> **What You'll Learn:**
>
> * How to send a new user invitation
> * How to accept and activate your SensorUp account
> * How to enable secure 2-step verification
> [!WARNING]
>
> **Common Pitfalls:**
>
> * Skipping the phone number field (use 999-999-9999 if needed)
> * Entering the wrong email—invites only work for the entered email address
## Role-Based Access Control
When creating a new user, you'll assign them one of the following roles:
* **Viewer:** Can view all data but cannot take any actions
* **Editor:** Can view all data and take limited actions (create/update emissions, issues, manage own assets and maps)
* **Administrator:** Can manage content across most sections (full CRUD on assets, forms, maps, and user management within their group)
* **Super Admin:** Full access across all features (internal SensorUp staff only)
> [!NOTE]
>
> [Learn more about roles and permissions →](/use-sensorup/user-management/User-roles-permissions)
## Your First Steps
**1. Invite a New User**
1. Click your **Avatar** icon in the bottom-left corner of the sidebar
2. Navigate to **User Management**
3. Click **Create User** at the top of the page

4. In the Add User form:
* Enter **First Name**, **Last Name**, **Email**, and **Phone Number**\
(Use `999-999-9999` if you don't have the phone number)
* Optionally set **Timezone** (defaults to browser-based location)
* Choose a **Role** (Viewer, Editor, Administrator, or Super Admin)
* Choose a **Group** (if available)
5. Click **Invite User**\
You'll see a confirmation banner at the top once the invite is sent.

**2. Accept the Invite and Create Account**
The invitee will receive an email with:
* A temporary **invite code** (copy it)
* A **Create Your Account** button
Invitee should:
1. Click **Create Your Account**
2. Enter their **email address**
3. Paste the **temporary code**
4. Click **Sign In**
5. Create a secure password
* Use a **memorable phrase** of 15+ characters (no need for symbols or digits)
* Use the eye icon to verify your password
* Click **Submit**

**3. Enable Two-Step Verification**
For added security, invitees must set up **2-step verification**:
1. Download a **Security App** (Authenticator) on your phone:
* Google Authenticator, Authy, Duo Mobile, LastPass Authenticator, Microsoft Authenticator
2. Open the app and scan the **QR Code** shown
3. Or switch to **manual entry** and type in the provided key
4. The app will generate a **6-digit code**
5. Enter the code into SensorUp and click **Continue**
✅ You'll now see a success screen confirming your account is ready. Click **Sign In** to enter the platform.

**4. You're In!**
Your new account is now ready to use. You can access your workspace based on your role and group.
> [!TIP]
>
> **You Did It!**\
> ✅ Sent or accepted your first user invite\
> ✅ Created a secure account\
> ✅ Enabled two-step verification
## What's a Security App?
A **Security App** (also called an Authenticator) generates time-based one-time passwords that refresh every 30 seconds.\
Even if someone gets your code, it won't work after 30 seconds.
Recommended apps:
* Google Authenticator
* Authy
* Duo Mobile
* LastPass Authenticator
* Microsoft Authenticator
Every time you sign in, you'll be asked to enter the current code shown in your app to complete login securely.
## What's Next?
You're now part of the SensorUp platform. Start exploring how to manage your profile or invite more teammates.
> [card] [Understanding Roles and Permissions](/use-sensorup/user-management/User-roles-permissions)
>
> Learn what each user role means and what access they have.
> [card] [Account Setup](/use-sensorup/user-management/account-setup)
>
> Complete your account setup and configure your profile settings.