Edmodo

Before writing a single line of configuration, confirm that you are not trying to build against Edmodo. Edmodo shut down permanently in September 2022. There are no API endpoints, no authentication tokens, no account login, and no data exports available. The domain may still exist but the platform and all associated developer services are gone. Any code or configuration targeting Edmodo will not work. Now choose your replacement based on your context: **Google Classroom** is the right choice if your school or organization already uses Google Workspace for Education. It has a free API, strong institutional adoption, and covers the core Edmodo use cases: class announcements, assignments, rosters, and coursework. The integration in FlutterFlow uses a `custom_action` with the `google_sign_in` package and OAuth 2.0 with education scopes. The main complexity is the OAuth consent screen setup in Google Cloud Console. **Canvas LMS** is the right choice if your institution has a Canvas deployment. Canvas has one of the most comprehensive LMS REST APIs available — it covers courses, enrollments, grades, assignments, announcements, and messaging. The FlutterFlow integration uses a conventional API Group with a bearer token, routed through a Cloud Function proxy. Canvas offers a free-for-teacher tier at canvas.instructure.com. **Moodle** is the right choice for self-hosted environments or institutions already on Moodle. Its Web Services API uses a unique function-based pattern where every call hits the same endpoint with a `wsfunction` query parameter. The FlutterFlow integration uses an API Group with this pattern. Moodle is open-source and free — the institution pays only for hosting. Pick one platform and proceed to the relevant configuration steps. Each platform has its own dedicated guide in the FlutterFlow integrations library (see related integrations below) with full step-by-step detail.

Regardless of which platform you choose, credentials must never live in your FlutterFlow Dart code. A Firebase Cloud Function (or Supabase Edge Function) handles all credential management. The implementation differs slightly per platform: **For Google Classroom:** The OAuth 2.0 client secret must not be in Dart. Set up a Cloud Function that accepts a refresh token (obtained on-device by the `google_sign_in` custom action) and exchanges it for a new access token via Google's token endpoint. The function stores the client secret in environment variables and returns only the short-lived access token to FlutterFlow. **For Canvas LMS:** Your Canvas API token (generated in Canvas Account → Settings → New Access Token) is sensitive — it gives full account access. Store it in a Cloud Function environment variable. The function acts as a proxy: FlutterFlow calls the Cloud Function with the Canvas endpoint path and parameters, and the function forwards the request to your Canvas instance with the token in the Authorization header. **For Moodle:** The Moodle Web Services token (generated in Site administration → Server → Web services → Manage tokens) must also be proxied. The Cloud Function accepts the `wsfunction` name and parameters, then calls `https://your-moodle.edu/webservice/rest/server.php` with the token and `moodlewsrestformat=json`. Deploy your chosen proxy function to Firebase and note the HTTPS trigger URL — you will configure this as a separate API Group in FlutterFlow named after your chosen platform ('Classroom Proxy', 'Canvas Proxy', or 'Moodle Proxy').

1// Cloud Function proxy example for Canvas LMS
2// index.js (Node.js 18+)
3const functions = require('firebase-functions');
4const axios = require('axios');
5
6const CANVAS_TOKEN = process.env.CANVAS_API_TOKEN;
7const CANVAS_BASE = process.env.CANVAS_BASE_URL; // e.g. https://yourschool.instructure.com
8
9exports.canvasProxy = functions.https.onRequest(async (req, res) => {
10  if (req.method !== 'POST') return res.status(405).send('Method Not Allowed');
11
12  const { endpoint, method = 'GET', params = {} } = req.body;
13  try {
14    const response = await axios({
15      method,
16      url: `${CANVAS_BASE}/api/v1${endpoint}`,
17      headers: { Authorization: `Bearer ${CANVAS_TOKEN}` },
18      params: method === 'GET' ? params : undefined,
19      data: method !== 'GET' ? params : undefined,
20    });
21    res.json(response.data);
22  } catch (err) {
23    const status = err.response?.status || 500;
24    res.status(status).json({ error: err.message });
25  }
26});

With the Cloud Function proxy deployed, set up the FlutterFlow API Group that your app will use to fetch LMS data. In FlutterFlow, click API Calls in the left nav → + Add → Create API Group. Name it after your chosen platform ('Google Classroom', 'Canvas LMS', or 'Moodle'). Set the Base URL to your Cloud Function's HTTPS trigger URL. **Canvas path:** Add API Calls with the `endpoint` body parameter set to the Canvas API path you need: `/courses` for course list, `/courses/{courseId}/assignments` for assignments, `/courses/{courseId}/students` for roster, `/courses/{courseId}/discussion_topics` for announcements. Each call POSTs to your Cloud Function proxy with `{ endpoint: '/courses', method: 'GET' }`. Parse the response using JSON Paths — Canvas returns arrays of objects with fields like `$.[:].id`, `$.[:].name`, `$.[:].enrollment_term_id`. **Moodle path:** Add API Calls where each call sends `{ wsfunction: 'core_course_get_courses', params: {} }` to your Moodle proxy function. Common wsfunction values: `core_course_get_courses` (list courses), `core_user_get_users` (user lookup), `gradereport_user_get_grade_items` (grades). Parse responses with JSON Paths for the function's specific return format. **Google Classroom path:** After the `google_sign_in` custom action runs and stores the access token in App State, configure a direct API Group (without the proxy) pointing to `https://classroom.googleapis.com/v1` with `Authorization: Bearer {{accessToken}}` as a shared header. Add calls for `/courses`, `/courses/{courseId}/students`, and `/courses/{courseId}/courseWork`. Test each API Call in the Response & Test tab to confirm you receive real data before proceeding to widget binding.

1// Sample JSON Paths for Canvas LMS /api/v1/courses response
2// $.[:].id            → course ID
3// $.[:].name          → course name
4// $.[:].course_code   → short course code
5// $.[:].enrollment_type → student or teacher
6// $.[:].start_at      → course start date
7
8// Sample JSON Paths for Moodle core_course_get_courses
9// $[:].id             → course ID
10// $[:].fullname       → full course name
11// $[:].shortname      → abbreviated name
12// $[:].summary        → course description
13// $[:].startdate      → Unix timestamp of start date

Edmodo's signature feature was the class feed — teachers and students could post updates, questions, and files in a shared stream, and parents could follow along. None of the three replacement platforms fully replicate this as a native mobile-first feed, but you can build it in Firebase or Supabase as your app's own data layer. For **Firebase:** Create a `feeds` Firestore collection with documents for each class feed. Each document has fields: `class_id` (linked to your LMS course ID), `author_id`, `author_name`, `content` (String), `created_at` (Timestamp), `type` (String: 'announcement' | 'question' | 'assignment'), and an `attachments` array. Enable real-time listeners in FlutterFlow by using a Firestore stream query on this collection filtered by `class_id`. New posts appear instantly without refreshing. For **Supabase:** Create a `feed_posts` table with equivalent columns. Enable the Supabase Realtime feature for this table. In FlutterFlow, use the Supabase Realtime integration (Settings & Integrations → Supabase → enable Realtime) so the feed ListView updates in real time when teachers or parents post. Add a 'New Post' floating action button that opens a bottom sheet with a text field and an optional image upload. The post action writes to Firestore/Supabase and optionally (for Canvas or Moodle) also creates an announcement via the LMS API so it appears in both your app's feed and the institution's LMS. This dual-write pattern is what truly replaces Edmodo — your app is the engagement layer, the LMS is the institutional record. For parent-teacher private messaging (another Edmodo staple), add a `messages` collection/table with `sender_id`, `recipient_id`, `content`, `sent_at`, and a `thread_id` linking to a course. Build a simple messaging UI in FlutterFlow with Firestore/Supabase real-time listeners.

1// Firestore security rules for the social feed
2rules_version = '2';
3service cloud.firestore {
4  match /databases/{database}/documents {
5    // Feed posts — teachers write, all class members read
6    match /feeds/{postId} {
7      allow read: if request.auth != null
8        && request.auth.uid in resource.data.allowed_readers;
9      allow create: if request.auth != null
10        && request.auth.token.role == 'teacher';
11      allow update, delete: if request.auth != null
12        && request.auth.uid == resource.data.author_id;
13    }
14    // Private messages — sender and recipient only
15    match /messages/{messageId} {
16      allow read, write: if request.auth != null
17        && (request.auth.uid == resource.data.sender_id
18            || request.auth.uid == resource.data.recipient_id);
19    }
20  }
21}

With the replacement LMS integrated and the social feed rebuilt, do a complete end-to-end test of your FlutterFlow app before publishing. Verify the authentication flow first: for Google Classroom, confirm the OAuth consent screen appears correctly on a physical device (it will NOT work in web preview), the correct education scopes are requested, and the access token is stored in App State successfully. For Canvas or Moodle, confirm the Cloud Function proxy returns real data when called from FlutterFlow. Check the data binding on every screen: course lists should show real courses from your LMS, roster screens should show real enrolled students, and the social feed should show posts from your Firebase/Supabase backend in real time. Create a test post from a teacher account and verify it appears on a student account's feed without refreshing. Run a search through your project's custom code, App Values, and any hardcoded strings for any reference to 'edmodo', 'api.edmodo.com', or any Edmodo URL — these must all be removed. There should be no code in your FlutterFlow project that attempts to contact any Edmodo endpoint. Finally, test on both iOS and Android physical devices. For Google Classroom specifically, the OAuth flow requires platform-specific configuration (reversed client ID in Info.plist for iOS, SHA-1 fingerprint + google-services.json for Android) — verify that sign-in works on both platforms before publishing. If you need help completing the migration or configuring the Cloud Function proxy for your specific LMS, RapidDev's team builds FlutterFlow integrations like this every week — free scoping call at rapidevelopers.com/contact.