🤖 Meta AI Python SDK

Unleash the Power of Meta AI with Python 🚀

A modern, feature-rich Python SDK providing seamless access to Meta AI's cutting-edge capabilities: Chat with Llama 3, Generate Images, Create AI Videos - All Without API Keys!

🎯 Quick Start • 📖 Documentation • 💡 Examples • 🎬 Video Generation

✨ Why Choose This SDK?

🎯 Zero Configuration

No API keys needed! Just install and start coding

⚡ Lightning Fast

Optimized for performance Real-time responses

🔥 Feature Complete

Chat • Images • Videos All in one SDK

🌟 Core Capabilities

✅ Current Status Notice:
Chat, Image, and Video functionality are now working with cookie-based authentication plus the Meta AI OAuth token used by the SDK and API server.
Image & Video Generation remain fully functional using simple cookie-based authentication (only 2 required cookies).
See CHANGELOG.md for release history and implementation updates.

Feature	Description	Status
💬 Intelligent Chat	Powered by Llama 3 with internet access	✅ Working
📤 Image Upload	Upload images for generation/analysis	✅ Working
🎨 Image Generation	Create stunning AI-generated images	✅ Working
🎬 Video Generation	Generate videos from text or uploaded images	✅ Working
🔍 Image Analysis	Describe, analyze, and extract info from images	✅ Working
🌐 Real-time Data	Get current information via Bing integration	✅ Working
📚 Source Citations	Responses include verifiable sources	✅ Working
🔄 Streaming Support	Real-time response streaming	✅ Working
🔐 Cookie Authentication	Uses session cookies (no problematic tokens)	✅ Working
🌍 Proxy Support	Route requests through proxies	✅ Working

📦 Installation

SDK Only (Lightweight)

For using Meta AI as a Python library:

pip install metaai-sdk

SDK + API Server

For deploying as a REST API service:

pip install metaai-sdk[api]

From Source

git clone https://github.com/mir-ashiq/metaai-api.git
cd metaai-api
pip install -e .          # SDK only
pip install -e ".[api]"   # SDK + API server

System Requirements: Python 3.7+ • Internet Connection • That's it!

🚀 Quick Start

Note: Chat functionality is available. Use the working Chat, Image Generation, and Video Generation features below.

Example 1: Generate Images (WORKING ✅)

from metaai_api import MetaAI

# Initialize with cookie-based authentication
ai = MetaAI()

# Generate images
result = ai.generate_image_new(
    prompt="a beautiful sunset over mountains",
    orientation="LANDSCAPE"  # LANDSCAPE, VERTICAL, or SQUARE
)

if result["success"]:
    print(f"Generated {len(result['image_urls'])} images:")
    for url in result["image_urls"]:
        print(url)

Output:

Generated 4 images:
https://scontent-arn2-1.xx.fbcdn.net/o1/v/t0/f2/m421/AQN...
https://scontent-arn2-1.xx.fbcdn.net/o1/v/t0/f2/m421/AQM...
https://scontent-arn2-1.xx.fbcdn.net/o1/v/t0/f2/m421/AQO...
https://scontent-arn2-1.xx.fbcdn.net/o1/v/t0/f2/m421/AQM...

Example 2: Generate Videos (WORKING ✅)

from metaai_api import MetaAI

ai = MetaAI()

# Generate video (auto-polls for URLs by default)
result = ai.generate_video_new("waves crashing on a beach at sunset")

if result["success"]:
    print(f"Generated {len(result['video_urls'])} videos:")
    for url in result["video_urls"]:
        print(url)

    # IDs for extension workflows
    print("Media IDs:", result.get("media_ids", []))

Output:

Generated 4 videos:
https://scontent.xx.fbcdn.net/o1/v/t6/f2/.../video1.mp4?...
https://scontent.xx.fbcdn.net/o1/v/t6/f2/.../video2.mp4?...
https://scontent.xx.fbcdn.net/o1/v/t6/f2/.../video3.mp4?...
https://scontent.xx.fbcdn.net/o1/v/t6/f2/.../video4.mp4?...

Media IDs: ['956278367576451', '956278364243118', '956278370909784', '956278374243117']

Quick Return (No Polling):

# For faster response (~17s), disable auto-polling
result = ai.generate_video_new(
    "waves crashing",
    auto_poll=False  # Returns immediately with conversation ID
)

if result["success"]:
    print(f"View your videos at: https://www.meta.ai/prompt/{result['conversation_id']}")

Example 3: Upload & Use Images (WORKING ✅)

from metaai_api import MetaAI

ai = MetaAI()

# Complex calculation
question = "If I invest $10,000 at 7% annual interest compounded monthly for 5 years, how much will I have?"
response = ai.prompt(question)

print(response["message"])

Output:

With an initial investment of $10,000 at a 7% annual interest rate compounded monthly
over 5 years, you would have approximately $14,176.25.

Here's the breakdown:
- Principal: $10,000
- Interest Rate: 7% per year (0.583% per month)
- Time: 5 years (60 months)
- Compound Frequency: Monthly
- Total Interest Earned: $4,176.25
- Final Amount: $14,176.25

This calculation uses the compound interest formula: A = P(1 + r/n)^(nt)

🔐 Authentication Options

The SDK uses simple cookie-based authentication. Minimum required:

from metaai_api import MetaAI

# Minimum cookies required
cookies = {
    "datr": "your_datr_value",
    "ecto_1_sess": "your_ecto_1_sess_value"  # Most important for generation
}

ai = MetaAI(cookies=cookies)

Optional cookies (improves compatibility in some regions):

# More complete cookie set (recommended)
cookies = {
    "datr": "your_datr_value",
    "abra_sess": "your_abra_sess_value",  # Optional - some regions (e.g., Indonesia) may not have this
    "ecto_1_sess": "your_ecto_1_sess_value"  # Most important for generation
}

ai = MetaAI(cookies=cookies)

Alternative: Load from environment variables

import os
from metaai_api import MetaAI

# Cookies from .env file
ai = MetaAI()  # Automatically loads from META_AI_* environment variables

💡 Note: Token fetching (lsd/fb_dtsg) has been removed. Generation APIs work perfectly with just datr + ecto_1_sess cookies!

💬 Chat Features

Streaming Responses

Watch responses appear in real-time, like ChatGPT:

from metaai_api import MetaAI

ai = MetaAI()

print("🤖 AI: ", end="", flush=True)
for chunk in ai.prompt("Explain quantum computing in simple terms", stream=True):
    print(chunk["message"], end="", flush=True)
print("\n")

Output:

🤖 AI: Quantum computing is like having a super-powered calculator that can solve
problems in completely new ways. Instead of regular computer bits that are either
0 or 1, quantum computers use "qubits" that can be both 0 and 1 at the same time -
imagine flipping a coin that's both heads and tails until you look at it! This
special ability allows quantum computers to process massive amounts of information
simultaneously, making them incredibly fast for specific tasks like drug discovery,
cryptography, and complex simulations.

Conversation Context

Have natural back-and-forth conversations:

from metaai_api import MetaAI

ai = MetaAI()

# First question
response1 = ai.prompt("What are the three primary colors?")
print("Q1:", response1["message"][:100])

# Follow-up question (maintains context)
response2 = ai.prompt("How do you mix them to make purple?")
print("Q2:", response2["message"][:150])

# Start fresh conversation
response3 = ai.prompt("What's the capital of France?", new_conversation=True)
print("Q3:", response3["message"][:50])

Output:

Q1: The three primary colors are Red, Blue, and Yellow. These colors cannot be created by mixing...

Q2: To make purple, you mix Red and Blue together. The exact shade of purple depends on the ratio - more red creates a reddish-purple (like magenta)...

Q3: The capital of France is Paris, located in the...

Using Proxies

Route your requests through a proxy:

from metaai_api import MetaAI

# Configure proxy
proxy = {
    'http': 'http://your-proxy-server:8080',
    'https': 'https://your-proxy-server:8080'
}

ai = MetaAI(proxy=proxy)
response = ai.prompt("Hello from behind a proxy!")
print(response["message"])

🌐 REST API Server (Optional)

Deploy Meta AI as a REST API service! Chat, image, and video endpoints are fully functional.

Note: Chat now uses the OAuth token extracted from Meta AI and the same SDK flow is exposed through the API server.

Installation

pip install metaai-sdk[api]

Setup

Get your Meta AI cookies (see Cookie Setup section)
Create .env file:

META_AI_DATR=your_datr_cookie
META_AI_ECTO_1_SESS=your_ecto_1_sess_cookie

# Optional (recommended when available)
META_AI_ABRA_SESS=your_abra_sess_cookie

Start the server:

uvicorn metaai_api.api_server:app --host 0.0.0.0 --port 8000

Server starts instantly (no token pre-fetching delays).

API Endpoints

Endpoint	Method	Description	Status
`/healthz`	GET	Health check	✅ Working
`/upload`	POST	Upload images for generation	✅ Working
`/image`	POST	Generate images from text	✅ Working
`/video`	POST	Generate video (blocks until complete)	✅ Working
`/video/extend`	POST	Extend video from media ID	✅ Working
`/video/async`	POST	Start async video generation	✅ Working
`/video/jobs/{job_id}`	GET	Poll async job status	✅ Working
`/chat`	POST	Send chat messages	✅ Working

Example Usage (Working Endpoints)

import requests

BASE_URL = "http://localhost:8000"

# Health check
response = requests.get(f"{BASE_URL}/healthz")
print(response.json())  # {"status": "ok"}

# Image generation
images = requests.post(f"{BASE_URL}/image", json={
    "prompt": "Cyberpunk cityscape at night",
    "orientation": "LANDSCAPE"  # LANDSCAPE, VERTICAL, or SQUARE
}, timeout=200)
result = images.json()
if result["success"]:
    for url in result["image_urls"]:
        print(url)

# Video generation (synchronous)
video = requests.post(f"{BASE_URL}/video", json={
    "prompt": "waves crashing on beach"
}, timeout=400)
result = video.json()
if result["success"]:
    print("Video URLs:", result.get("video_urls", []))
    print("Media IDs:", result.get("media_ids", []))

# Extend video from media ID
extended = requests.post(f"{BASE_URL}/video/extend", json={
    "media_id": result["media_ids"][0]
}, timeout=400)
extend_result = extended.json()
if extend_result["success"]:
    print("Extended URLs:", extend_result.get("video_urls", []))
    print("Extended Media IDs:", extend_result.get("media_ids", []))

# Async video generation
job = requests.post(f"{BASE_URL}/video/async", json={
    "prompt": "sunset over ocean"
})
job_id = job.json()["job_id"]

# Poll for result
import time
while True:
    status = requests.get(f"{BASE_URL}/video/jobs/{job_id}")
    data = status.json()
    if data["status"] == "completed":
        print("Video URLs:", data["result"]["video_urls"])
        break
    time.sleep(5)

Performance

Image Generation: ~2 minutes (returns 4 images)
Video Generation: ~40-60 seconds (returns 3-4 videos)
Upload: < 5 seconds

Test All Features

Run test scripts in this order for fastest troubleshooting and full coverage:

Chat flow (SDK + optional API):

python scripts/test_chat_feature.py --test-api --base-url http://127.0.0.1:8001 --output tests/integration/outputs/chat_feature_test_results.json

Image upload + image generation + animation from uploaded image:

python scripts/test_upload_and_generation.py --base-url http://127.0.0.1:8001

Full SDK + API validation (chat, upload, image, video, async, extend):

python scripts/test_all_features_complete.py --base-url http://127.0.0.1:8001 --output tests/integration/outputs/feature_test_report_sdk_api_final.json

Add --video-auto-poll if you want the runner to wait for final media URLs during video checks.

Extend Animation + Image Upload Workflow (SDK)

from metaai_api import MetaAI

ai = MetaAI()

# 1) Upload an image
upload = ai.upload_image("path/to/image.jpg")
if not upload.get("success"):
    raise RuntimeError("Upload failed")

media_id = upload["media_id"]
metadata = {
    "file_size": upload.get("file_size", 0),
    "mime_type": upload.get("mime_type", "image/jpeg"),
}

# 2) Animate the uploaded image into video
video = ai.generate_video_new(
    prompt="animate this image with smooth cinematic motion",
    media_ids=[media_id],
    attachment_metadata=metadata,
)

# 3) Extend one generated animation clip
if video.get("success") and video.get("media_ids"):
    extended = ai.extend_video(video["media_ids"][0])
    print("Extended video URLs:", extended.get("video_urls", []))

🎬 Video Generation

Create AI-generated videos from text descriptions!

Setup: Get Your Cookies

Visit meta.ai in your browser and login
Open DevTools (F12) → Application tab → Cookies → https://meta.ai
Copy these required cookie values:
- datr
- ecto_1_sess (most important for generation)
Optional (if available):
- abra_sess

💡 Note: Only datr and ecto_1_sess cookies are needed. No tokens (lsd/fb_dtsg) required!

🔄 Automatic Cookie Refresh

Cookies (especially ecto_1_sess) expire periodically. The SDK now includes automatic cookie refresh scripts!

Option 1: Manual Export (Recommended)

# 1. In your browser: Copy as cURL → save as curl.json
# 2. Run the extractor
python refresh_cookies.py

When to Refresh?

The SDK automatically detects expired cookies and will show:

❌ Cookie Expired: ecto_1_sess needs to be refreshed
Run: python auto_refresh_cookies.py

Key Cookies:

ecto_1_sess ⭐ - Session token (expires frequently, must refresh)
rd_challenge - Challenge cookie (auto-updated by SDK)
ps_l, ps_n - Portal flags (optional, may improve reliability)

Example 1: Generate Your First Video

from metaai_api import MetaAI

# Your browser cookies (minimum required)
cookies = {
    "datr": "your_datr_value_here",
    "ecto_1_sess": "your_ecto_1_sess_value_here"
}

# Optional cookie (recommended when available)
# cookies["abra_sess"] = "your_abra_sess_value_here"

# Initialize with cookies
ai = MetaAI(cookies=cookies)

# Generate a video
result = ai.generate_video_new("A majestic lion walking through the African savanna at sunset")

if result["success"]:
    print("✅ Video generated successfully!")
    print(f"🎬 Generated {len(result['video_urls'])} videos")
    for i, url in enumerate(result['video_urls'], 1):
        print(f"   Video {i}: {url[:80]}...")
    print(f"📝 Prompt: {result['prompt']}")
else:
    print("⏳ Video generation failed, check your cookies")

Output:

✅ Sending video generation request...
✅ Video generation request sent successfully!
⏳ Waiting before polling...
🔄 Polling for video URLs (Attempt 1/20)...
✅ Video URLs found!

✅ Video generated successfully!
🎬 Generated 3 videos
   Video 1: https://scontent.xx.fbcdn.net/v/t66.36240-6/video1.mp4?...
   Video 2: https://scontent.xx.fbcdn.net/v/t66.36240-6/video2.mp4?...
   Video 3: https://scontent.xx.fbcdn.net/v/t66.36240-6/video3.mp4?...
📝 Prompt: A majestic lion walking through the African savanna at sunset

How to Get Your Cookies

Open https://meta.ai in your browser and login
Press F12 → Application tab
Navigate to Cookies → https://meta.ai
Copy these required values:
- datr
- ecto_1_sess
- optional: abra_sess
Add to your Python code or .env file

Example 2: Generate Multiple Videos

from metaai_api import MetaAI
import time

ai = MetaAI(cookies=cookies)

prompts = [
    "A futuristic city with flying cars at night",
    "Ocean waves crashing on a tropical beach",
    "Northern lights dancing over a snowy mountain"
]

videos = []
for i, prompt in enumerate(prompts, 1):
    print(f"\n🎬 Generating video {i}/{len(prompts)}: {prompt}")
    result = ai.generate_video(prompt, verbose=False)

    if result["success"]:
        videos.append(result["video_urls"][0])
        print(f"✅ Success! URL: {result['video_urls'][0][:50]}...")
    else:
        print("⏳ Still processing...")

    time.sleep(5)  # Be nice to the API

print(f"\n🎉 Generated {len(videos)} videos successfully!")

Output:

🎬 Generating video 1/3: A futuristic city with flying cars at night
✅ Success! URL: https://scontent.xx.fbcdn.net/v/t66.36240-6/1234...

🎬 Generating video 2/3: Ocean waves crashing on a tropical beach
✅ Success! URL: https://scontent.xx.fbcdn.net/v/t66.36240-6/5678...

🎬 Generating video 3/3: Northern lights dancing over a snowy mountain
✅ Success! URL: https://scontent.xx.fbcdn.net/v/t66.36240-6/9012...

🎉 Generated 3 videos successfully!

Example 3: Advanced Video Generation with Orientation

from metaai_api import MetaAI

ai = MetaAI(cookies=cookies)

# Generate video with specific orientation (default is VERTICAL)
result = ai.generate_video(
    prompt="A time-lapse of a flower blooming",
    orientation="VERTICAL",   # Options: "LANDSCAPE", "VERTICAL", "SQUARE"
    wait_before_poll=15,      # Wait 15 seconds before checking
    max_attempts=50,          # Try up to 50 times
    wait_seconds=3,           # Wait 3 seconds between attempts
    verbose=True              # Show detailed progress
)

# Generate landscape video for widescreen
result_landscape = ai.generate_video(
    prompt="Panoramic view of sunset over mountains",
    orientation="LANDSCAPE"   # Wide format (16:9)
)

if result["success"]:
    print(f"\n🎬 Your videos are ready!")
    print(f"🔗 Generated {len(result['video_urls'])} videos:")
    for i, url in enumerate(result['video_urls'], 1):
        print(f"   Video {i}: {url}")
    print(f"⏱️ Generated at: {result['timestamp']}")

Supported Video Orientations:

"LANDSCAPE" - Wide/horizontal (16:9) - ideal for widescreen, cinematic content
"VERTICAL" - Tall/vertical (9:16) - ideal for mobile, stories, reels (default)
"SQUARE" - Equal dimensions (1:1) - ideal for social posts


📖 **Full Video Guide:** See [GENERATION_API.md](GENERATION_API.md) for complete documentation.

---

## 📤 Image Upload & Analysis

Upload images to Meta AI for analysis, similar image generation, and video creation:

### Upload & Analyze Images

```python
from metaai_api import MetaAI

# Initialize with cookies (datr + ecto_1_sess required)
ai = MetaAI(cookies={
    "datr": "your_datr_cookie",
    "ecto_1_sess": "your_ecto_1_sess_cookie",
    # "abra_sess": "your_abra_sess_cookie"  # Optional
})

# Step 1: Upload an image
result = ai.upload_image("path/to/image.jpg")

if result["success"]:
    media_id = result["media_id"]
    metadata = {
        'file_size': result['file_size'],
        'mime_type': result['mime_type']
    }

    # Step 2: Analyze the image
    response = ai.prompt(
        message="What do you see in this image? Describe it in detail.",
        media_ids=[media_id],
        attachment_metadata=metadata
    )
    print(f"🔍 Analysis: {response['message']}")

    # Step 3: Generate similar images
    response = ai.prompt(
        message="Create a similar image in watercolor painting style",
        media_ids=[media_id],
        attachment_metadata=metadata,
        is_image_generation=True
    )
    print(f"🎨 Generated {len(response['media'])} similar images")

    # Step 4: Generate video from image
    video = ai.generate_video(
        prompt="generate a video with zoom in effect on this image",
        media_ids=[media_id],
        attachment_metadata=metadata
    )
    if video["success"]:
        print(f"🎬 Video: {video['video_urls'][0]}")

Output:

🔍 Analysis: The image captures a serene lake scene set against a majestic mountain backdrop. In the foreground, there's a small, golden-yellow wooden boat with a bright yellow canopy floating on calm, glass‑like water...

🎨 Generated 4 similar images

🎬 Video: https://scontent.fsxr1-2.fna.fbcdn.net/o1/v/t6/f2/m421/video.mp4

📖 Full Image Upload Guide: See examples/image_upload_example.py for a practical upload workflow.

🎨 Image Generation

Generate AI-powered images with customizable orientations (requires Facebook authentication):

from metaai_api import MetaAI

# Initialize with Facebook credentials
ai = MetaAI(fb_email="your_email@example.com", fb_password="your_password")

# Generate images with default orientation (VERTICAL)
response = ai.prompt("Generate an image of a cyberpunk cityscape at night with neon lights")

# Or specify orientation explicitly
response_landscape = ai.prompt(
    "Generate an image of a panoramic mountain landscape",
    orientation="LANDSCAPE"  # Options: "LANDSCAPE", "VERTICAL", "SQUARE"
)

response_vertical = ai.prompt(
    "Generate an image of a tall waterfall",
    orientation="VERTICAL"  # Tall/portrait format (default)
)

response_square = ai.prompt(
    "Generate an image of a centered mandala pattern",
    orientation="SQUARE"  # Square format (1:1)
)

# Display results (Meta AI generates 4 images by default)
print(f"🎨 Generated {len(response['media'])} images:")
for i, image in enumerate(response['media'], 1):
    print(f"  Image {i}: {image['url']}")
    print(f"  Prompt: {image['prompt']}")

Supported Orientations:

"LANDSCAPE" - Wide/horizontal format (16:9) - ideal for panoramas, landscapes
"VERTICAL" - Tall/vertical format (9:16) - ideal for portraits, mobile content (default)
"SQUARE" - Equal dimensions (1:1) - ideal for social media, profile images

Output:

🎨 Generated 4 images:
  Image 1: https://scontent.xx.fbcdn.net/o1/v/t0/f1/m247/img1.jpeg
  Prompt: a cyberpunk cityscape at night with neon lights

  Image 2: https://scontent.xx.fbcdn.net/o1/v/t0/f1/m247/img2.jpeg
  Prompt: a cyberpunk cityscape at night with neon lights

  Image 3: https://scontent.xx.fbcdn.net/o1/v/t0/f1/m247/img3.jpeg
  Prompt: a cyberpunk cityscape at night with neon lights

  Image 4: https://scontent.xx.fbcdn.net/o1/v/t0/f1/m247/img4.jpeg
  Prompt: a cyberpunk cityscape at night with neon lights

💡 Examples

Explore working examples in the examples/ directory:

File	Description	Features
📄 image_workflow_complete.py	Complete image workflow	Upload, analyze, generate images/video
📄 simple_example.py	Quick start guide	Basic chat + video generation
📄 video_generation.py	Video generation	Multiple examples, error handling
📄 test_example.py	Testing suite	Validation and testing

Run an Example

# Clone the repository
git clone https://github.com/mir-ashiq/metaai-api.git
cd metaai-api

# Run simple example
python examples/simple_example.py

# Run video generation examples
python examples/video_generation.py

📖 Documentation

📚 Complete Guides

Document	Description
📘 Quick Start	SDK/API setup and first requests
📘 Generation API	Image/video generation details
📙 Changes & Cookies	Cookie setup and known caveats
📕 Contributing Guide	How to contribute to the project
📔 Changelog	Version history and updates
📓 Security Policy	Security best practices

🔧 API Reference

MetaAI Class

class MetaAI:
    def __init__(
        self,
        fb_email: Optional[str] = None,
        fb_password: Optional[str] = None,
        cookies: Optional[dict] = None,
        proxy: Optional[dict] = None
    )

Methods:

prompt(message, stream=False, new_conversation=False)
- Send a chat message
- Returns: dict with message, sources, and media
generate_video(prompt, wait_before_poll=10, max_attempts=30, wait_seconds=5, verbose=True)
- Generate a video from text - Returns: dict with success, video_urls (actual media URLs), media_ids, conversation_id, prompt, timestamp
extend_video(media_id, source_media_url=None, conversation_id=None, wait_before_poll=10, max_attempts=30, wait_seconds=5, verbose=True)
- Extend a previously generated video from a media ID
  - Returns: dict with success, video_urls (extended playable URLs), media_ids, conversation_id, source_media_id, timestamp

VideoGenerator Class

from metaai_api import VideoGenerator

# Direct video generation
generator = VideoGenerator(cookies_str="your_cookies_as_string")
result = generator.generate_video("your prompt here")

# One-liner generation
result = VideoGenerator.quick_generate(
    cookies_str="your_cookies",
    prompt="your prompt"
)

🎯 Use Cases

1. Research Assistant

ai = MetaAI()
research = ai.prompt("Summarize recent breakthroughs in fusion energy")
print(research["message"])
# Get cited sources
for source in research["sources"]:
    print(f"📌 {source['title']}: {source['link']}")

2. Content Creation

ai = MetaAI(cookies=cookies)

# Generate video content
promo_video = ai.generate_video("Product showcase with smooth camera movements")

# Generate images
thumbnails = ai.prompt("Generate a YouTube thumbnail for a tech review video")

3. Educational Tool

ai = MetaAI()

# Explain complex topics
explanation = ai.prompt("Explain blockchain technology to a 10-year-old")

# Get homework help
solution = ai.prompt("Solve: 2x + 5 = 13, show steps")

4. Real-time Information

ai = MetaAI()

# Current events
news = ai.prompt("What are the top technology news today?")

# Sports scores
scores = ai.prompt("Latest Premier League scores")

# Market data
stocks = ai.prompt("Current S&P 500 index value")

🛠️ Advanced Configuration

Environment Variables

Store credentials securely:

# .env file
META_AI_DATR=your_datr_value
META_AI_ECTO_1_SESS=your_ecto_1_sess_value

# Optional
META_AI_ABRA_SESS=your_abra_sess_value

Load in Python:

from metaai_api import MetaAI

# Automatically loads from environment variables
ai = MetaAI()

# Or manually load with dotenv
import os
from dotenv import load_dotenv

load_dotenv()
cookies = {
    "datr": os.getenv("META_AI_DATR"),
    "ecto_1_sess": os.getenv("META_AI_ECTO_1_SESS")
}

if os.getenv("META_AI_ABRA_SESS"):
    cookies["abra_sess"] = os.getenv("META_AI_ABRA_SESS")

ai = MetaAI(cookies=cookies)

Error Handling

from metaai_api import MetaAI

ai = MetaAI(cookies=cookies)

try:
    result = ai.generate_video("Your prompt")

    if result["success"]:
        print(f"✅ Video: {result['video_urls'][0]}")
    else:
        print("⏳ Video still processing, try again later")

except ValueError as e:
    print(f"❌ Configuration error: {e}")
except ConnectionError as e:
    print(f"❌ Network error: {e}")
except Exception as e:
    print(f"❌ Unexpected error: {e}")

🌟 Project Structure

metaai-api/
│
├── 📁 src/metaai_api/        # Core package
│   ├── __init__.py            # Package initialization
│   ├── main.py                # MetaAI class
│   ├── video_generation.py    # Video generation
│   ├── client.py              # Client utilities
│   ├── utils.py               # Helper functions
│   └── exceptions.py          # Custom exceptions
│
├── 📁 examples/               # Usage examples
│   ├── simple_example.py      # Quick start
│   ├── video_generation.py    # Video examples
│   └── test_example.py        # Testing
│
├── 📁 .github/                # GitHub configuration
│   ├── workflows/             # CI/CD pipelines
│   └── README.md
│
├── 📄 README.md               # This file
├── 📄 QUICK_START.md
├── 📄 GENERATION_API.md
├── 📄 CHANGES_AND_COOKIES.md
├── 📄 CONTRIBUTING.md
├── 📄 CHANGELOG.md
├── 📄 SECURITY.md
├── 📄 LICENSE                 # MIT License
├── 📄 pyproject.toml          # Project metadata
└── 📄 requirements.txt        # Dependencies

🤝 Contributing

We welcome contributions! Here's how you can help:

🐛 Report Bugs - Open an issue
💡 Suggest Features - Share your ideas
📝 Improve Docs - Help us document better
🔧 Submit PRs - Fix bugs or add features

See CONTRIBUTING.md for detailed guidelines.

📜 License

This project is licensed under the MIT License - see LICENSE for details.

⚖️ Disclaimer

This project is an independent implementation and is not officially affiliated with Meta Platforms, Inc. or any of its affiliates.

✅ Educational and development purposes
✅ Use responsibly and ethically
✅ Comply with Meta's Terms of Service
✅ Respect usage limits and policies

Llama 3 License: Visit llama.com/llama3/license for Llama 3 usage terms.

🙏 Acknowledgments

Meta AI - For providing the AI capabilities
Llama 3 - The powerful language model
Open Source Community - For inspiration and support

📞 Support & Community

💬 Questions? GitHub Discussions
🐛 Bug Reports GitHub Issues
📧 Contact imseldrith@gmail.com
⭐ Star us on GitHub

🚀 Quick Links

Resource	Link
📦 PyPI Package	pypi.org/project/metaai-sdk
🐙 GitHub Repository	github.com/mir-ashiq/metaai-api
📖 Full Documentation	Quick Start • Generation API
💬 Get Help	Issues • Discussions

_{Meta AI Python SDK v2.0.0 | Made with ❤️ by mir-ashiq | MIT License}

⭐ Star this repo if you find it useful!

Name		Name	Last commit message	Last commit date
Latest commit History 54 Commits
.github/workflows		.github/workflows
examples		examples
scripts		scripts
src/metaai_api		src/metaai_api
test		test
.env.example		.env.example
.gitattributes		.gitattributes
.gitignore		.gitignore
CHANGELOG.md		CHANGELOG.md
CHANGES_AND_COOKIES.md		CHANGES_AND_COOKIES.md
CONTRIBUTING.md		CONTRIBUTING.md
Dockerfile		Dockerfile
GENERATION_API.md		GENERATION_API.md
LICENSE		LICENSE
MANIFEST.in		MANIFEST.in
QUICK_START.md		QUICK_START.md
README.md		README.md
SECURITY.md		SECURITY.md
dev_tests		dev_tests
extract_access_token.py		extract_access_token.py
pyproject.toml		pyproject.toml
requirements.txt		requirements.txt
test_all_generation.py		test_all_generation.py
test_video_generation.py		test_video_generation.py

Folders and files

Latest commit

History

Repository files navigation

🤖 Meta AI Python SDK

✨ Why Choose This SDK?

🎯 Zero Configuration

⚡ Lightning Fast

🔥 Feature Complete

🌟 Core Capabilities

📦 Installation

SDK Only (Lightweight)

SDK + API Server

From Source

🚀 Quick Start

Example 1: Generate Images (WORKING ✅)

Example 2: Generate Videos (WORKING ✅)

Example 3: Upload & Use Images (WORKING ✅)

🔐 Authentication Options

💬 Chat Features

Streaming Responses

Conversation Context

Using Proxies

🌐 REST API Server (Optional)

Installation

Setup

API Endpoints

Example Usage (Working Endpoints)

Performance

Test All Features

Extend Animation + Image Upload Workflow (SDK)

🎬 Video Generation

Setup: Get Your Cookies

🔄 Automatic Cookie Refresh

Option 1: Manual Export (Recommended)

When to Refresh?

Example 1: Generate Your First Video

How to Get Your Cookies

Example 2: Generate Multiple Videos

Example 3: Advanced Video Generation with Orientation

🎨 Image Generation

💡 Examples

Run an Example

📖 Documentation

📚 Complete Guides

🔧 API Reference

MetaAI Class

VideoGenerator Class

🎯 Use Cases

1. Research Assistant

2. Content Creation

3. Educational Tool

4. Real-time Information

🛠️ Advanced Configuration

Environment Variables

Error Handling

🌟 Project Structure

🤝 Contributing

📜 License

⚖️ Disclaimer

🙏 Acknowledgments

📞 Support & Community

🚀 Quick Links

About

Topics

Resources

License

Contributing

Security policy

Uh oh!

Stars

Watchers

Forks

Releases

Packages 0

Uh oh!

Contributors 1

Languages

Packages