Why use Flutter for astrology apps?

Flutter enables single codebase for iOS and Android with 60fps performance, native-looking Material and Cupertino widgets, hot reload for fast development, and smaller app sizes compared to React Native.

How does Vedika API handle birth chart calculations?

Vedika API uses astronomical-grade Swiss Ephemeris for planetary positions with verified precision. It supports both Vedic and Western astrology systems, including 120+ calculations like planetary positions, houses, aspects, yogas, dashas, and more.

Can I integrate AI chatbot in my Flutter astrology app?

Yes, Vedika API is an astrology API with AI-powered natural language capabilities. Users can ask questions like 'When will I get married?' or 'Is this a good time to start a business?' and get personalized predictions based on their birth chart.

Build an Astrology App with Flutter & Vedika API

Flutter is revolutionizing mobile app development with its single codebase approach. For astrology app developers, this means building once and deploying to both iOS and Android with native performance, beautiful Material Design widgets, and blazing-fast hot reload.

In this comprehensive tutorial, we'll build a production-ready astrology app from scratch using Flutter and Vedika API - the only B2B astrology API with AI-powered conversational capabilities. By the end, you'll have a fully functional app with birth charts, daily horoscopes, AI chatbot, and real-time predictions.

                What You'll Build: A cross-platform astrology app featuring birth chart input, AI-powered predictions, streaming chat responses, daily horoscopes, and a polished Material Design UI. The app will work seamlessly on iOS and Android with production-grade error handling.
            

Why Flutter for Astrology Apps?

Single Codebase

Write once, deploy to iOS, Android, web, and desktop. Reduce development time by 60%.

60fps Performance

Dart compiles to native ARM code. Smooth animations for chart visualizations and transitions.

Hot Reload

See changes instantly without restarting the app. Perfect for UI iteration.

Material Design

Beautiful, native-looking widgets out of the box. Cupertino widgets for iOS styling.

Prerequisites

Before starting, ensure you have:

Flutter SDK installed (version 3.16 or later)
Xcode (for iOS development) or Android Studio
Vedika API key (get free key here)
Basic knowledge of Dart programming

Step 1: Setup Flutter Project

Create a new Flutter project and add required dependencies:

# Create new Flutter project
flutter create astrology_app
cd astrology_app

# Open in your IDE
code .
            

Add Dependencies

Update your pubspec.yaml file with these packages:

# pubspec.yaml
name: astrology_app
description: AI-powered astrology app with Vedika API

dependencies:
  flutter:
    sdk: flutter

  # HTTP client
  http: ^1.2.0

  # State management
  provider: ^6.1.1

  # Date/time handling
  intl: ^0.19.0

  # Location services
  geolocator: ^11.0.0
  geocoding: ^3.0.0

  # UI components
  flutter_svg: ^2.0.9
  shimmer: ^3.0.0

dev_dependencies:
  flutter_test:
    sdk: flutter
  flutter_lints: ^3.0.1
            

Run flutter pub get to install dependencies.

Step 2: Create Vedika API Service Class

Create a dedicated service class to handle all Vedika API interactions. This follows best practices for separation of concerns:

// lib/services/vedika_service.dart
import 'dart:convert';
import 'package:http/http.dart' as http;

class VedikaService {
  static const String _baseUrl = 'https://api.vedika.io';
  final String apiKey;

  VedikaService({required this.apiKey});

  /// Get birth chart data
  Future<Map<String, dynamic>> getBirthChart({
    required DateTime birthDateTime,
    required double latitude,
    required double longitude,
    String timezone = '+05:30',
  }) async {
    final response = await http.post(
      Uri.parse('$_baseUrl/api/vedika/chat'),
      headers: {
        'Content-Type': 'application/json',
        'x-api-key': apiKey,
      },
      body: json.encode({
        'question': 'Generate my complete birth chart',
        'birthDetails': {
          'datetime': birthDateTime.toIso8601String(),
          'latitude': latitude,
          'longitude': longitude,
          'timezone': timezone,
        },
      }),
    );

    if (response.statusCode == 200) {
      return json.decode(response.body);
    } else {
      throw Exception('Failed to fetch birth chart: ${response.body}');
    }
  }

  /// Get daily horoscope
  Future<String> getDailyHoroscope({
    required String zodiacSign,
    DateTime? birthDateTime,
    double? latitude,
    double? longitude,
  }) async {
    String question = 'What is today\'s horoscope for $zodiacSign? '
        'Include predictions for career, love, health, and finance.';

    final body = {
      'question': question,
    };

    // Add birth details if available for personalized predictions
    if (birthDateTime != null && latitude != null && longitude != null) {
      body['birthDetails'] = {
        'datetime': birthDateTime.toIso8601String(),
        'latitude': latitude,
        'longitude': longitude,
        'timezone': '+05:30',
      };
    }

    final response = await http.post(
      Uri.parse('$_baseUrl/api/vedika/chat'),
      headers: {
        'Content-Type': 'application/json',
        'x-api-key': apiKey,
      },
      body: json.encode(body),
    );

    if (response.statusCode == 200) {
      final data = json.decode(response.body);
      return data['answer'] ?? 'No prediction available';
    } else {
      throw Exception('Failed to fetch horoscope');
    }
  }

  /// Chat with AI astrologer
  Future<String> askQuestion({
    required String question,
    required DateTime birthDateTime,
    required double latitude,
    required double longitude,
  }) async {
    final response = await http.post(
      Uri.parse('$_baseUrl/api/vedika/chat'),
      headers: {
        'Content-Type': 'application/json',
        'x-api-key': apiKey,
      },
      body: json.encode({
        'question': question,
        'birthDetails': {
          'datetime': birthDateTime.toIso8601String(),
          'latitude': latitude,
          'longitude': longitude,
          'timezone': '+05:30',
        },
      }),
    );

    if (response.statusCode == 200) {
      final data = json.decode(response.body);
      return data['answer'] ?? 'No answer available';
    } else {
      throw Exception('Failed to get answer');
    }
  }
}
            

Step 3: Build Birth Chart Input Form

Create a beautiful form to collect user's birth details with date/time pickers and location input:

// lib/screens/birth_details_screen.dart
import 'package:flutter/material.dart';
import 'package:intl/intl.dart';

class BirthDetailsScreen extends StatefulWidget {
  @override
  State<BirthDetailsScreen> createState() => _BirthDetailsScreenState();
}

class _BirthDetailsScreenState extends State<BirthDetailsScreen> {
  final _formKey = GlobalKey<FormState>();
  DateTime? _selectedDate;
  TimeOfDay? _selectedTime;
  final _latController = TextEditingController();
  final _lonController = TextEditingController();

  void _selectDate() async {
    final date = await showDatePicker(
      context: context,
      initialDate: DateTime.now().subtract(Duration(days: 365 * 25)),
      firstDate: DateTime(1900),
      lastDate: DateTime.now(),
    );
    if (date != null) {
      setState(() => _selectedDate = date);
    }
  }

  void _selectTime() async {
    final time = await showTimePicker(
      context: context,
      initialTime: TimeOfDay(hour: 12, minute: 0),
    );
    if (time != null) {
      setState(() => _selectedTime = time);
    }
  }

  void _submitForm() {
    if (_formKey.currentState!.validate() &&
        _selectedDate != null &&
        _selectedTime != null) {
      final birthDateTime = DateTime(
        _selectedDate!.year,
        _selectedDate!.month,
        _selectedDate!.day,
        _selectedTime!.hour,
        _selectedTime!.minute,
      );

      Navigator.pushNamed(
        context,
        '/birth-chart',
        arguments: {
          'datetime': birthDateTime,
          'latitude': double.parse(_latController.text),
          'longitude': double.parse(_lonController.text),
        },
      );
    }
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text('Birth Details'),
        backgroundColor: Colors.deepPurple,
      ),
      body: SingleChildScrollView(
        padding: EdgeInsets.all(16),
        child: Form(
          key: _formKey,
          child: Column(
            crossAxisAlignment: CrossAxisAlignment.stretch,
            children: [
              // Date Picker
              InkWell(
                onTap: _selectDate,
                child: InputDecorator(
                  decoration: InputDecoration(
                    labelText: 'Birth Date',
                    border: OutlineInputBorder(),
                    prefixIcon: Icon(Icons.calendar_today),
                  ),
                  child: Text(
                    _selectedDate == null
                        ? 'Select date'
                        : DateFormat('dd MMM yyyy').format(_selectedDate!),
                  ),
                ),
              ),
              SizedBox(height: 16),

              // Time Picker
              InkWell(
                onTap: _selectTime,
                child: InputDecorator(
                  decoration: InputDecoration(
                    labelText: 'Birth Time',
                    border: OutlineInputBorder(),
                    prefixIcon: Icon(Icons.access_time),
                  ),
                  child: Text(
                    _selectedTime == null
                        ? 'Select time'
                        : _selectedTime!.format(context),
                  ),
                ),
              ),
              SizedBox(height: 16),

              // Latitude Input
              TextFormField(
                controller: _latController,
                keyboardType: TextInputType.number,
                decoration: InputDecoration(
                  labelText: 'Latitude',
                  border: OutlineInputBorder(),
                  prefixIcon: Icon(Icons.location_on),
                  hintText: 'e.g., 28.6139',
                ),
                validator: (val) => val?.isEmpty ?? true
                    ? 'Enter latitude' : null,
              ),
              SizedBox(height: 16),

              // Longitude Input
              TextFormField(
                controller: _lonController,
                keyboardType: TextInputType.number,
                decoration: InputDecoration(
                  labelText: 'Longitude',
                  border: OutlineInputBorder(),
                  prefixIcon: Icon(Icons.location_on),
                  hintText: 'e.g., 77.2090',
                ),
                validator: (val) => val?.isEmpty ?? true
                    ? 'Enter longitude' : null,
              ),
              SizedBox(height: 24),

              // Submit Button
              ElevatedButton(
                onPressed: _submitForm,
                style: ElevatedButton.styleFrom(
                  backgroundColor: Colors.deepPurple,
                  padding: EdgeInsets.symmetric(vertical: 16),
                ),
                child: Text(
                  'Generate Birth Chart',
                  style: TextStyle(fontSize: 16),
                ),
              ),
            ],
          ),
        ),
      ),
    );
  }
}
            

Step 4: Display Birth Chart Results

Create a screen to show birth chart data in a beautiful, scrollable layout:

// lib/screens/birth_chart_screen.dart
import 'package:flutter/material.dart';
import '../services/vedika_service.dart';

class BirthChartScreen extends StatefulWidget {
  @override
  State<BirthChartScreen> createState() => _BirthChartScreenState();
}

class _BirthChartScreenState extends State<BirthChartScreen> {
  bool _loading = true;
  Map<String, dynamic>? _chartData;
  String? _error;

  @override
  void didChangeDependencies() {
    super.didChangeDependencies();
    _fetchBirthChart();
  }

  void _fetchBirthChart() async {
    final args = ModalRoute.of(context)!.settings.arguments
        as Map<String, dynamic>;

    final service = VedikaService(
      apiKey: 'YOUR_API_KEY_HERE', // Use secure storage in production
    );

    try {
      final data = await service.getBirthChart(
        birthDateTime: args['datetime'],
        latitude: args['latitude'],
        longitude: args['longitude'],
      );

      setState(() {
        _chartData = data;
        _loading = false;
      });
    } catch (e) {
      setState(() {
        _error = e.toString();
        _loading = false;
      });
    }
  }

  @override
  Widget build(BuildContext context) {
    if (_loading) {
      return Scaffold(
        appBar: AppBar(title: Text('Birth Chart')),
        body: Center(child: CircularProgressIndicator()),
      );
    }

    if (_error != null) {
      return Scaffold(
        appBar: AppBar(title: Text('Birth Chart')),
        body: Center(child: Text('Error: $_error')),
      );
    }

    return Scaffold(
      appBar: AppBar(
        title: Text('Your Birth Chart'),
        backgroundColor: Colors.deepPurple,
      ),
      body: SingleChildScrollView(
        padding: EdgeInsets.all(16),
        child: Column(
          crossAxisAlignment: CrossAxisAlignment.start,
          children: [
            // Chart Analysis Card
            Card(
              elevation: 4,
              child: Padding(
                padding: EdgeInsets.all(16),
                child: Column(
                  crossAxisAlignment: CrossAxisAlignment.start,
                  children: [
                    Text(
                      'Birth Chart Analysis',
                      style: TextStyle(
                        fontSize: 20,
                        fontWeight: FontWeight.bold,
                      ),
                    ),
                    SizedBox(height: 12),
                    Text(
                      _chartData?['answer'] ?? 'No data',
                      style: TextStyle(fontSize: 15, height: 1.5),
                    ),
                  ],
                ),
              ),
            ),
          ],
        ),
      ),
    );
  }
}
            

Step 5: Add Daily Horoscope Feature

Create a zodiac sign selector and daily horoscope display:

// lib/screens/daily_horoscope_screen.dart
import 'package:flutter/material.dart';
import '../services/vedika_service.dart';

class DailyHoroscopeScreen extends StatefulWidget {
  @override
  State<DailyHoroscopeScreen> createState() => _DailyHoroscopeScreenState();
}

class _DailyHoroscopeScreenState extends State<DailyHoroscopeScreen> {
  String? _selectedSign;
  bool _loading = false;
  String? _prediction;

  final List<Map<String, String>> zodiacSigns = [
    {'name': 'Aries', 'emoji': '♈'},
    {'name': 'Taurus', 'emoji': '♉'},
    {'name': 'Gemini', 'emoji': '♊'},
    {'name': 'Cancer', 'emoji': '♋'},
    {'name': 'Leo', 'emoji': '♌'},
    {'name': 'Virgo', 'emoji': '♍'},
    {'name': 'Libra', 'emoji': '♎'},
    {'name': 'Scorpio', 'emoji': '♏'},
    {'name': 'Sagittarius', 'emoji': '♐'},
    {'name': 'Capricorn', 'emoji': '♑'},
    {'name': 'Aquarius', 'emoji': '♒'},
    {'name': 'Pisces', 'emoji': '♓'},
  ];

  void _fetchHoroscope(String sign) async {
    setState(() {
      _selectedSign = sign;
      _loading = true;
    });

    final service = VedikaService(apiKey: 'YOUR_API_KEY_HERE');

    try {
      final prediction = await service.getDailyHoroscope(zodiacSign: sign);
      setState(() {
        _prediction = prediction;
        _loading = false;
      });
    } catch (e) {
      setState(() {
        _prediction = 'Error fetching horoscope';
        _loading = false;
      });
    }
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text('Daily Horoscope'),
        backgroundColor: Colors.deepPurple,
      ),
      body: Column(
        children: [
          // Zodiac Grid
          Expanded(
            flex: 2,
            child: GridView.builder(
              padding: EdgeInsets.all(16),
              gridDelegate: SliverGridDelegateWithFixedCrossAxisCount(
                crossAxisCount: 3,
                crossAxisSpacing: 12,
                mainAxisSpacing: 12,
              ),
              itemCount: zodiacSigns.length,
              itemBuilder: (context, index) {
                final sign = zodiacSigns[index];
                final isSelected = _selectedSign == sign['name'];

                return InkWell(
                  onTap: () => _fetchHoroscope(sign['name']!),
                  child: Container(
                    decoration: BoxDecoration(
                      color: isSelected
                          ? Colors.deepPurple
                          : Colors.white,
                      borderRadius: BorderRadius.circular(12),
                      border: Border.all(
                        color: Colors.deepPurple,
                        width: 2,
                      ),
                    ),
                    child: Column(
                      mainAxisAlignment: MainAxisAlignment.center,
                      children: [
                        Text(
                          sign['emoji']!,
                          style: TextStyle(fontSize: 32),
                        ),
                        SizedBox(height: 4),
                        Text(
                          sign['name']!,
                          style: TextStyle(
                            color: isSelected
                                ? Colors.white
                                : Colors.black,
                            fontWeight: FontWeight.bold,
                          ),
                        ),
                      ],
                    ),
                  ),
                );
              },
            ),
          ),

          // Prediction Display
          if (_loading)
            Expanded(
              flex: 3,
              child: Center(child: CircularProgressIndicator()),
            )
          else if (_prediction != null)
            Expanded(
              flex: 3,
              child: SingleChildScrollView(
                padding: EdgeInsets.all(16),
                child: Card(
                  elevation: 4,
                  child: Padding(
                    padding: EdgeInsets.all(16),
                    child: Column(
                      crossAxisAlignment: CrossAxisAlignment.start,
                      children: [
                        Text(
                          'Today\'s Horoscope for $_selectedSign',
                          style: TextStyle(
                            fontSize: 18,
                            fontWeight: FontWeight.bold,
                          ),
                        ),
                        SizedBox(height: 12),
                        Text(
                          _prediction!,
                          style: TextStyle(fontSize: 15, height: 1.5),
                        ),
                      ],
                    ),
                  ),
                ),
              ),
            )
          else
            Expanded(
              flex: 3,
              child: Center(
                child: Text('Select a zodiac sign'),
              ),
            ),
        ],
      ),
    );
  }
}
            

Step 6: Add AI Chatbot Integration

Create an interactive chat screen where users can ask astrology questions:

// lib/screens/chat_screen.dart
import 'package:flutter/material.dart';
import '../services/vedika_service.dart';

class ChatMessage {
  final String text;
  final bool isUser;

  ChatMessage({required this.text, required this.isUser});
}

class ChatScreen extends StatefulWidget {
  final DateTime birthDateTime;
  final double latitude;
  final double longitude;

  ChatScreen({
    required this.birthDateTime,
    required this.latitude,
    required this.longitude,
  });

  @override
  State<ChatScreen> createState() => _ChatScreenState();
}

class _ChatScreenState extends State<ChatScreen> {
  final List<ChatMessage> _messages = [];
  final _textController = TextEditingController();
  final _scrollController = ScrollController();
  bool _loading = false;

  void _sendMessage() async {
    if (_textController.text.isEmpty || _loading) return;

    final userMessage = _textController.text;
    setState(() {
      _messages.add(ChatMessage(text: userMessage, isUser: true));
      _loading = true;
    });
    _textController.clear();
    _scrollToBottom();

    final service = VedikaService(apiKey: 'YOUR_API_KEY_HERE');

    try {
      final answer = await service.askQuestion(
        question: userMessage,
        birthDateTime: widget.birthDateTime,
        latitude: widget.latitude,
        longitude: widget.longitude,
      );

      setState(() {
        _messages.add(ChatMessage(text: answer, isUser: false));
        _loading = false;
      });
      _scrollToBottom();
    } catch (e) {
      setState(() {
        _messages.add(ChatMessage(
          text: 'Error: ${e.toString()}',
          isUser: false,
        ));
        _loading = false;
      });
    }
  }

  void _scrollToBottom() {
    Future.delayed(Duration(milliseconds: 100), () {
      if (_scrollController.hasClients) {
        _scrollController.animateTo(
          _scrollController.position.maxScrollExtent,
          duration: Duration(milliseconds: 300),
          curve: Curves.easeOut,
        );
      }
    });
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text('Ask Vedika AI'),
        backgroundColor: Colors.deepPurple,
      ),
      body: Column(
        children: [
          // Messages List
          Expanded(
            child: ListView.builder(
              controller: _scrollController,
              padding: EdgeInsets.all(16),
              itemCount: _messages.length,
              itemBuilder: (context, index) {
                final message = _messages[index];
                return Align(
                  alignment: message.isUser
                      ? Alignment.centerRight
                      : Alignment.centerLeft,
                  child: Container(
                    margin: EdgeInsets.only(bottom: 12),
                    padding: EdgeInsets.symmetric(
                      horizontal: 16,
                      vertical: 12,
                    ),
                    decoration: BoxDecoration(
                      color: message.isUser
                          ? Colors.deepPurple
                          : Colors.grey[200],
                      borderRadius: BorderRadius.circular(12),
                    ),
                    constraints: BoxConstraints(
                      maxWidth: MediaQuery.of(context).size.width * 0.7,
                    ),
                    child: Text(
                      message.text,
                      style: TextStyle(
                        color: message.isUser ? Colors.white : Colors.black87,
                      ),
                    ),
                  ),
                );
              },
            ),
          ),

          // Loading Indicator
          if (_loading)
            Padding(
              padding: EdgeInsets.all(8),
              child: Text('Consulting the stars...'),
            ),

          // Input Field
          Container(
            padding: EdgeInsets.all(8),
            decoration: BoxDecoration(
              color: Colors.white,
              border: Border(top: BorderSide(color: Colors.grey[300]!)),
            ),
            child: Row(
              children: [
                Expanded(
                  child: TextField(
                    controller: _textController,
                    decoration: InputDecoration(
                      hintText: 'Ask about career, love, health...',
                      border: OutlineInputBorder(
                        borderRadius: BorderRadius.circular(24),
                      ),
                      contentPadding: EdgeInsets.symmetric(
                        horizontal: 16,
                        vertical: 12,
                      ),
                    ),
                    onSubmitted: (_) => _sendMessage(),
                  ),
                ),
                SizedBox(width: 8),
                IconButton(
                  onPressed: _loading ? null : _sendMessage,
                  icon: Icon(Icons.send),
                  color: Colors.deepPurple,
                ),
              ],
            ),
          ),
        ],
      ),
    );
  }
}
            

Step 7: Polish UI with Flutter Widgets

Create a beautiful home screen with navigation to all features:

// lib/screens/home_screen.dart
import 'package:flutter/material.dart';

class HomeScreen extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return Scaffold(
      body: Container(
        decoration: BoxDecoration(
          gradient: LinearGradient(
            begin: Alignment.topLeft,
            end: Alignment.bottomRight,
            colors: [
              Color(0xFF667eea),
              Color(0xFF764ba2),
            ],
          ),
        ),
        child: SafeArea(
          child: Column(
            children: [
              // Header
              Padding(
                padding: EdgeInsets.all(24),
                child: Column(
                  children: [
                    Text(
                      'Cosmic Insights',
                      style: TextStyle(
                        fontSize: 32,
                        fontWeight: FontWeight.bold,
                        color: Colors.white,
                      ),
                    ),
                    SizedBox(height: 8),
                    Text(
                      'Powered by Vedika AI',
                      style: TextStyle(
                        fontSize: 16,
                        color: Colors.white70,
                      ),
                    ),
                  ],
                ),
              ),

              // Feature Cards
              Expanded(
                child: ListView(
                  padding: EdgeInsets.all(16),
                  children: [
                    _buildFeatureCard(
                      context,
                      icon: Icons.auto_graph,
                      title: 'Birth Chart',
                      description: 'Get your complete Vedic birth chart',
                      route: '/birth-details',
                    ),
                    SizedBox(height: 16),
                    _buildFeatureCard(
                      context,
                      icon: Icons.calendar_today,
                      title: 'Daily Horoscope',
                      description: 'Read your daily predictions',
                      route: '/daily-horoscope',
                    ),
                    SizedBox(height: 16),
                    _buildFeatureCard(
                      context,
                      icon: Icons.chat,
                      title: 'Ask Vedika AI',
                      description: 'Chat with AI astrologer',
                      route: '/chat',
                    ),
                  ],
                ),
              ),
            ],
          ),
        ),
      ),
    );
  }

  Widget _buildFeatureCard(
    BuildContext context, {
    required IconData icon,
    required String title,
    required String description,
    required String route,
  }) {
    return Card(
      elevation: 8,
      shape: RoundedRectangleBorder(borderRadius: BorderRadius.circular(16)),
      child: InkWell(
        onTap: () => Navigator.pushNamed(context, route),
        borderRadius: BorderRadius.circular(16),
        child: Padding(
          padding: EdgeInsets.all(20),
          child: Row(
            children: [
              Container(
                padding: EdgeInsets.all(16),
                decoration: BoxDecoration(
                  color: Colors.deepPurple.withOpacity(0.1),
                  borderRadius: BorderRadius.circular(12),
                ),
                child: Icon(icon, size: 32, color: Colors.deepPurple),
              ),
              SizedBox(width: 16),
              Expanded(
                child: Column(
                  crossAxisAlignment: CrossAxisAlignment.start,
                  children: [
                    Text(
                      title,
                      style: TextStyle(
                        fontSize: 18,
                        fontWeight: FontWeight.bold,
                      ),
                    ),
                    SizedBox(height: 4),
                    Text(
                      description,
                      style: TextStyle(color: Colors.grey[600]),
                    ),
                  ],
                ),
              ),
              Icon(Icons.arrow_forward_ios, color: Colors.grey),
            ],
          ),
        ),
      ),
    );
  }
}
            

Step 8: Configure Routes & Run

Set up navigation routes in your main app file:

// lib/main.dart
import 'package:flutter/material.dart';
import 'screens/home_screen.dart';
import 'screens/birth_details_screen.dart';
import 'screens/birth_chart_screen.dart';
import 'screens/daily_horoscope_screen.dart';
import 'screens/chat_screen.dart';

void main() {
  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Cosmic Insights',
      theme: ThemeData(
        primarySwatch: Colors.deepPurple,
        visualDensity: VisualDensity.adaptivePlatformDensity,
      ),
      initialRoute: '/',
      routes: {
        '/': (context) => HomeScreen(),
        '/birth-details': (context) => BirthDetailsScreen(),
        '/birth-chart': (context) => BirthChartScreen(),
        '/daily-horoscope': (context) => DailyHoroscopeScreen(),
        '/chat': (context) => ChatScreen(
          birthDateTime: DateTime.now(),
          latitude: 28.6139,
          longitude: 77.2090,
        ),
      },
    );
  }
}
            

Run your app:

# Run on connected device/emulator
flutter run

# Run on iOS simulator
flutter run -d iphone

# Run on Android emulator
flutter run -d emulator
            

Ready to Build Your Astrology App?

Get your free Vedika API key - no credit card required. 10 free queries to start.

Get Your API Key

Advanced Features to Add

1. Streaming Chat Responses

For real-time streaming predictions, you can implement Server-Sent Events (SSE) or WebSocket support. Vedika AI supports streaming responses for a more interactive chat experience.

2. Push Notifications for Daily Horoscope

Use Firebase Cloud Messaging to send daily horoscope notifications. Schedule API calls at midnight to fetch predictions for each user's zodiac sign.

3. Multi-Language Support

Vedika API supports 30 languages. Add language selection to get predictions in Hindi, Tamil, Telugu, Bengali, and more.

// Request in Hindi
final response = await service.askQuestion(
  question: 'मेरा करियर कैसा रहेगा?',
  birthDateTime: birthDateTime,
  latitude: latitude,
  longitude: longitude,
);
            

4. Chart Visualization

Use packages like fl_chart or syncfusion_flutter_charts to create beautiful birth chart visualizations with planetary positions and houses.

5. Compatibility Matching

Add a feature for users to check compatibility with partners by comparing two birth charts:

// Ask about compatibility
final compatibility = await service.askQuestion(
  question: 'How compatible am I with someone born on '
      'March 15, 1992 at 10:30 AM in Mumbai?',
  birthDateTime: myBirthDateTime,
  latitude: myLatitude,
  longitude: myLongitude,
);
            

Production Best Practices

Secure API Key Storage

Never hardcode API keys. Use flutter_secure_storage for secure key storage:

// Store API key securely
final storage = FlutterSecureStorage();
await storage.write(key: 'vedika_api_key', value: 'vk_live_...');

// Retrieve API key
final apiKey = await storage.read(key: 'vedika_api_key');
            

Error Handling

Implement robust error handling with user-friendly messages:

try {
  final data = await service.getBirthChart(...);
} on SocketException {
  // No internet connection
  showDialog(...);
} on HttpException {
  // API error
  showDialog(...);
} catch (e) {
  // Unknown error
  print('Error: $e');
}
            

Caching for Offline Access

Cache birth chart data using hive or shared_preferences to reduce API calls and enable offline viewing.

Deployment

Build for iOS

# Build iOS release
flutter build ios --release

# Archive and upload to App Store Connect
open ios/Runner.xcworkspace
            

Build for Android

# Build APK
flutter build apk --release

# Build App Bundle (recommended for Play Store)
flutter build appbundle --release
            

Sample Questions Users Can Ask

Guide your users with suggested questions they can ask the AI chatbot:

"What are my career prospects this year?"
"When will I get married according to my horoscope?"
"Is this a good time to start a new business?"
"What gemstone should I wear for luck?"
"Explain my current Mahadasha period"
"What does my 7th house say about relationships?"
"Am I going through Sade Sati?"
"What are the yogas in my birth chart?"

Why Choose Vedika API?

AI-Powered

Only astrology API with natural language AI chatbot. No complex calculations needed.

300+ Calculations

Birth charts, planetary positions, yogas, doshas, dashas, transits, and more.

30 Languages

Support for Hindi, Tamil, Telugu, Bengali, Gujarati, Marathi, Kannada, and 23 more.

97% Accuracy

astronomical-grade Swiss Ephemeris for planetary calculations with astronomical precision.

Production-Ready

99.9% uptime, rate limiting, secure authentication, comprehensive error handling.

Developer-Friendly

RESTful API, detailed docs, code examples, and responsive support team.

Pricing

Vedika API offers transparent, pay-as-you-go pricing starting at just $12/month:

Starter Plan: $12/month - Perfect for indie developers
Professional Plan: $60/month - For growing apps
Business Plan: $120/month - For production apps
Enterprise Plan: $240/month - Unlimited usage with top-up credits

All plans include the full API with 120+ calculations, AI chatbot, and multi-language support. View detailed pricing

Conclusion

Building an astrology app with Flutter and Vedika API is remarkably straightforward. The key advantages:

Cross-platform efficiency: Single Dart codebase for iOS and Android
No astrology expertise required: AI handles complex calculations and interpretations
Natural language interface: Users ask questions in plain language
Production-ready API: 99.9% uptime, secure, scalable infrastructure
Beautiful UI: Flutter's Material Design widgets make it easy to build stunning UIs
Fast development: Hot reload enables rapid iteration and testing

Next steps:

Get your free Vedika API key at vedika.io/signup
Clone the full source code from our Flutter starter template
Customize the UI to match your brand
Add advanced features like compatibility matching and transit predictions
Deploy to App Store and Play Store

Have questions? Check out our comprehensive documentation or reach out to our support team. We're here to help you build amazing astrology apps!

About Vedika Intelligence: Vedika is the only B2B astrology API with AI-powered chatbot capabilities, serving production apps worldwide. Our multi-agent swarm intelligence system enables natural language astrology queries with verified precision, supporting both Vedic and Western astrology systems across 30 languages.