AccessE11 Automation: API Alternative for Citizen Issue Tracking, Public Works Dispatch Sync, and SLA Reporting

Introduction

AccessE11 is a citizen services and 311-style request management platform used by local governments and municipalities to track citizen issues, service requests, and public works operations. While AccessE11 provides web-based case and dispatch tools, the platform has limited or restricted API access for most government users. Browser automation provides a reliable solution to automate citizen issue tracking and resolution, sync service requests with public works dispatch systems, and automate SLA reporting directly through the AccessE11 web interface, enabling streamlined citizen services and operational compliance.

Why Use Browser Automation for AccessE11?

• Limited API Access: AccessE11 has restricted or no API access for most government users and agencies
• Citizen Issue Tracking: Automate creation, assignment, status updates, and resolution of citizen-reported issues
• Service Request Sync: Sync service requests (potholes, streetlights, code enforcement, etc.) with public works dispatch and field crews
• SLA Reporting: Automate SLA and performance reporting by category, department, or time period
• Dispatch Integration: Export or push requests to dispatch systems for work orders and crew assignment
• Multi-Department Workflows: Track and route requests across departments and ensure consistent status updates
• Compliance and Transparency: Generate reports for council, citizens, and oversight requirements
• Dashboard-Only Features: Many case and dispatch views are only available through the web interface

Setting Up AccessE11 Automation

Here's how to automate AccessE11 workflows using browser automation:

import { chromium } from 'playwright';

const response = await fetch("https://api.anchorbrowser.io/api/sessions", {
  method: "POST",
  headers: {
    "anchor-api-key": "YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    'headless': false,
    'proxy': { 'type': 'residential', 'country': 'US' }
  }),
});

const { id } = await response.json();
const connectionString = `wss://connect.anchorbrowser.io?apiKey=YOUR_API_KEY&sessionId=${id}`;

const browser = await chromium.connectOverCDP(connectionString);
const context = browser.contexts()[0];
const ai = context.serviceWorkers()[0];
const page = context.pages()[0];

await page.goto("https://yourcity.accesse11.com/");

await ai.evaluate(JSON.stringify({
  prompt: 'Log in to AccessE11 using the provided credentials. Complete any security verification and wait for the dashboard to load.'
}));

Automating Citizen Issue Tracking and Resolution

Automate creation, assignment, and resolution of citizen-reported issues:

const automateCitizenIssueTracking = async (page, ai, issue) => {
  await ai.evaluate(JSON.stringify({
    prompt: 'Navigate to the Cases, Service Requests, or 311 Requests section in AccessE11'
  }));
  
  await ai.evaluate(JSON.stringify({
    prompt: 'Click Create New Request or Add Case'
  }));
  
  await ai.evaluate(JSON.stringify({
    prompt: `Create a service request with: Category: ${issue.category}, Description: ${issue.description}, Location: ${issue.location}, Contact: ${issue.contact || 'N/A'}. Set priority if required. Submit the request.`
  }));
  
  await page.waitForLoadState('networkidle');
  
  const caseNumber = await ai.evaluate(JSON.stringify({
    prompt: 'Read the new case or request number from the confirmation screen and return it'
  })).catch(() => null);
  
  return { caseNumber };
};

const updateIssueStatus = async (page, ai, caseId, status, notes) => {
  await ai.evaluate(JSON.stringify({
    prompt: `Search for case or request ${caseId} and open it`
  }));
  await ai.evaluate(JSON.stringify({
    prompt: `Update status to ${status}. Add notes: ${notes || 'N/A'}. Save changes.`
  }));
  await page.waitForLoadState('networkidle');
  return true;
};

Syncing Service Requests with Public Works Dispatch

Export service requests and sync with public works dispatch or work order systems:

const syncServiceRequestsWithDispatch = async (page, ai, filters) => {
  await ai.evaluate(JSON.stringify({
    prompt: 'Navigate to the Service Requests, Cases, or Dispatch section in AccessE11'
  }));
  
  await ai.evaluate(JSON.stringify({
    prompt: `Filter requests: status ${filters.status || 'open'}, category ${filters.category || 'all'}, date range ${filters.startDate || 'start'} to ${filters.endDate || 'end'}. Include only requests that need to be dispatched.`
  }));
  
  await ai.evaluate(JSON.stringify({
    prompt: 'Export the list of service requests including: case number, category, description, location, priority, status, created date, and assigned department. Export as Excel or CSV.'
  }));
  
  const download = await page.waitForEvent('download');
  const exportPath = await download.path();
  
  const requests = await parseCSV(exportPath);
  for (const req of requests) {
    await createWorkOrderInDispatch(req);
    await page.waitForTimeout(500);
  }
  return { exportPath, count: requests.length };
};

Exporting Service Requests for Dispatch

Export open or pending requests in a format ready for dispatch systems:

const exportServiceRequestsForDispatch = async (page, ai, category, dateRange) => {
  await ai.evaluate(JSON.stringify({
    prompt: 'Navigate to the Service Requests or Cases section'
  }));
  
  await ai.evaluate(JSON.stringify({
    prompt: `Filter by category ${category || 'all'} and created/updated date from ${dateRange.start} to ${dateRange.end}. Show only open or pending requests.`
  }));
  
  await ai.evaluate(JSON.stringify({
    prompt: 'Export request data including: case ID, category, description, address/location, latitude/longitude if available, priority, status, created date, and department. Export as CSV or Excel.'
  }));
  
  const download = await page.waitForEvent('download');
  return await download.path();
};

Automating SLA Reporting

Generate and export SLA and performance reports on a schedule:

const automateSLAReporting = async (page, ai, reportParams) => {
  const { reportType, dateRange, groupBy } = reportParams;
  
  await ai.evaluate(JSON.stringify({
    prompt: 'Navigate to the Reports, Analytics, or SLA section in AccessE11'
  }));
  
  await ai.evaluate(JSON.stringify({
    prompt: `Select ${reportType} (SLA Performance, Response Time, Resolution Time, or Volume by Category). Set date range from ${dateRange.start} to ${dateRange.end}. Group by ${groupBy || 'category'} if available.`
  }));
  
  await ai.evaluate(JSON.stringify({
    prompt: 'Generate the report. Include: case count, average response time, average resolution time, SLA met vs missed, and breakdown by category or department. Export as Excel or PDF.'
  }));
  
  const download = await page.waitForEvent('download');
  return await download.path();
};

Exporting SLA and Performance Reports

Export SLA and performance data by category or department:

const exportSLAReport = async (page, ai, reportType, period) => {
  await ai.evaluate(JSON.stringify({
    prompt: 'Navigate to the Reports or SLA section'
  }));
  
  await ai.evaluate(JSON.stringify({
    prompt: `Run ${reportType} report (SLA Summary, Response Time, Resolution Time, or Backlog) for period ${period}. Export the report.`
  }));
  
  const download = await page.waitForEvent('download');
  return await download.path();
};

Syncing with External Systems

Export case and request data for integration with GIS, asset management, or other government systems:

const syncToExternalSystem = async (page, ai, dataType) => {
  await ai.evaluate(JSON.stringify({
    prompt: 'Navigate to the Export or Reports section'
  }));
  
  await ai.evaluate(JSON.stringify({
    prompt: `Export ${dataType} (service requests, cases, SLA data, or dispatch summary) in the format required for our dispatch, GIS, or reporting system. Include all necessary fields.`
  }));
  
  const download = await page.waitForEvent('download');
  return await download.path();
};

Best Practices

• Security: Use secure credential storage and support MFA where required for government systems
• Rate Limiting: Add delays between requests (5–10 seconds) to avoid triggering security or rate limits
• Data Validation: Verify exported request and SLA data before syncing with dispatch or reporting systems
• Error Handling: Implement retry logic for transient failures and session timeouts
• Citizen Data: Handle contact and location data according to privacy and retention policies
• SLA Alignment: Run SLA reports on a schedule that matches your reporting cycles and council requirements
• Dispatch Sync: Avoid duplicate work orders by tracking which requests have already been sent to dispatch
• Audit Trail: Log automation actions for accountability and compliance
• Session Management: Handle session timeouts and re-authentication for scheduled jobs

Resources

• Anchor Browser Documentation - Complete API reference and guides
• Anchor Browser Playground - Try browser automation in your browser

Conclusion

Browser automation provides a flexible and reliable alternative to API access for AccessE11 citizen services and dispatch workflows. By leveraging intelligent browser agents, you can automate citizen issue tracking and resolution, sync service requests with public works dispatch, and automate SLA reporting—workflows that aren't easily achievable through manual processes or limited API access. Whether you need to track cases, push requests to dispatch, or generate SLA and performance reports, browser automation enables efficient citizen services operations for governments using AccessE11.

Start automating your AccessE11 workflows today and streamline your citizen services and public works operations!