Flipkart Marketplace Getting Started: Account, Keys, First Call (2026)

Getting started overview

Integrating with Flipkart Marketplace programmatically requires a structured approach, beginning with establishing a seller account and progressing to API credential acquisition and making initial requests. The platform prioritizes a secure and verified environment, meaning direct API access is typically granted after a seller has completed their registration and met specific criteria. This guide outlines the sequential steps to navigate the setup process, focusing on practical actions to get a first integration operational.

The overall flow for getting started with Flipkart Marketplace involves:

1. Seller Account Registration: Creating a seller profile on the Flipkart Seller Hub.
2. Verification and Onboarding: Completing necessary documentation and verification steps.
3. API Access Application: Requesting API credentials, often after a period of marketplace activity or for specific integration needs.
4. Credential Management: Obtaining and securely storing API keys and secrets.
5. First API Request: Executing a simple API call to confirm authentication and connectivity.

This process ensures that only authorized sellers and partners can interact with the Flipkart Marketplace APIs, maintaining data integrity and platform security. For general information on securing API communications, the OAuth 2.0 specification is a relevant industry standard often employed by marketplaces for authorization.

Quick reference table

Create an account and get keys

Accessing the Flipkart Marketplace APIs begins with establishing a seller presence on the platform. Unlike some open APIs, Flipkart's API access is typically gated, requiring sellers to first register and often demonstrate a level of activity before being granted programmatic access. This ensures that API usage aligns with established business operations on the marketplace.

Step 1: Register on Flipkart Seller Hub

Navigate to the official Flipkart Seller Hub and initiate the registration process. This typically involves providing:

• Your mobile number and email address.
• Your business name and address.
• GSTIN (Goods and Services Tax Identification Number) for Indian businesses.
• Bank account details for settlements.

Follow the on-screen prompts to complete the initial signup. You will likely need to verify your email and mobile number as part of this stage.

Step 2: Complete seller onboarding and verification

After initial registration, Flipkart requires sellers to complete a comprehensive onboarding process. This includes:

• KYC (Know Your Customer) Documentation: Uploading identity proof (e.g., PAN card) and address proof.
• Business Details: Providing details about your product categories, inventory, and shipping preferences.
• Bank Account Verification: Flipkart typically performs a small test transaction to verify your provided bank account.

Ensure all information is accurate and matches your official business records to avoid delays. The Flipkart Seller Hub provides a dashboard to track your onboarding progress and highlights any pending actions.

Step 3: Apply for API access

Once your seller account is fully active and verified, and you have potentially processed some initial orders through the seller portal, you can explore options for API access. Flipkart's API access is often tailored for specific integration partners or large sellers with significant operational needs. The exact path to apply for API credentials may vary:

• Seller Hub Integration Section: Check your Flipkart Seller Hub dashboard for an 'Integrations' or 'API Access' section. This is the most direct route for self-service API key generation if available for your seller tier.
• Partner Programs: If you are a solution provider or a large enterprise, you might need to engage with Flipkart's partner programs, which often include dedicated API support and access.
• Direct Contact: If self-service options are not immediately apparent, you may need to contact Flipkart Seller Support to inquire about API access for your specific use case. Be prepared to articulate your integration requirements and expected API usage.

Upon approval, you will be provided with API credentials, which typically include:

• API Key (Client ID): A unique identifier for your application.
• API Secret (Client Secret): A confidential key used to sign requests or obtain access tokens.

Treat your API Secret as sensitive information. For best practices on securing API keys, consult resources like AWS's best practices for access keys, which emphasize rotating keys and restricting permissions.

Your first request

After obtaining your API Key and Secret, the next critical step is to make a successful API call to verify your credentials and understand the API's structure. Flipkart's APIs typically use RESTful principles and often require requests to be signed or authenticated using an OAuth-like flow. While the exact endpoints and authentication methods can vary based on the specific API version and scope granted, a common initial step involves obtaining an access token or making a simple status check.

Authentication method overview

Flipkart APIs commonly employ a token-based authentication mechanism. This usually involves:

1. Sending your API Key and Secret to an authentication endpoint.
2. Receiving an access_token and potentially a refresh_token in response.
3. Including the access_token in the Authorization header of subsequent API requests.

The specific endpoint for obtaining an access token and the required parameters will be detailed in the API documentation provided by Flipkart upon granting access. For example, a request might involve a POST to an /oauth/token endpoint with your client ID and secret in the request body or as HTTP Basic Authentication headers.

Example pseudocode for obtaining an access token

Assuming a typical OAuth 2.0 Client Credentials flow:

import requests
import json

FLIPKART_AUTH_URL = "https://api.flipkart.com/oauth/token" # Placeholder URL
CLIENT_ID = "YOUR_CLIENT_ID"
CLIENT_SECRET = "YOUR_CLIENT_SECRET"

headers = {
    "Content-Type": "application/x-www-form-urlencoded"
}
data = {
    "grant_type": "client_credentials",
    "client_id": CLIENT_ID,
    "client_secret": CLIENT_SECRET
}

try:
    response = requests.post(FLIPKART_AUTH_URL, headers=headers, data=data)
    response.raise_for_status() # Raise an exception for HTTP errors
    token_data = response.json()
    access_token = token_data.get("access_token")
    
    if access_token:
        print(f"Successfully obtained access token: {access_token}")
        # Store this token securely and use for subsequent requests
    else:
        print("Failed to obtain access token. Response:")
        print(json.dumps(token_data, indent=2))

except requests.exceptions.RequestException as e:
    print(f"An error occurred during token request: {e}")
    if e.response is not None:
        print(f"Response status code: {e.response.status_code}")
        print(f"Response body: {e.response.text}")

Making a test API call

Once you have an access_token, you can use it to make a simple API call, such as fetching your seller profile information or a list of active listings. The specific endpoint for a test call will be provided in Flipkart's API documentation. A common pattern is to include the token in the Authorization header:

# ... (after obtaining access_token)

FLIPKART_API_BASE_URL = "https://api.flipkart.com/seller/v3" # Placeholder base URL
TEST_ENDPOINT = "/listings/active" # Example endpoint for active listings

api_headers = {
    "Authorization": f"Bearer {access_token}",
    "Content-Type": "application/json"
}

try:
    api_response = requests.get(f"{FLIPKART_API_BASE_URL}{TEST_ENDPOINT}", headers=api_headers)
    api_response.raise_for_status()
    print("Successfully made a test API call!")
    print(json.dumps(api_response.json(), indent=2))

except requests.exceptions.RequestException as e:
    print(f"An error occurred during API call: {e}")
    if e.response is not None:
        print(f"Response status code: {e.response.status_code}")
        print(f"Response body: {e.response.text}")

Successful execution of this code, resulting in a 2xx HTTP status code and meaningful JSON data, confirms that your API credentials are valid and you can communicate with the Flipkart Marketplace API.

Common next steps

After successfully making your first API call, you can proceed with more advanced integrations with Flipkart Marketplace:

• Explore API Documentation: Thoroughly review the official Flipkart API documentation specific to your granted access level. This will detail available endpoints for inventory management, order processing, product listings, and more.
• Inventory Management: Implement APIs to update stock levels, manage product availability, and synchronize inventory between your systems and Flipkart.
• Order Processing: Integrate APIs to fetch new orders, update order statuses (e.g., shipped, delivered), and manage returns.
• Product Listing and Updates: Use APIs to create new product listings, update existing product details, prices, and images.
• Webhook Configuration: Investigate if Flipkart offers webhooks for real-time notifications on events like new orders or order status changes. Webhooks can significantly reduce the need for constant polling. For general webhook security, Twilio's webhook security guide offers relevant principles.
• Error Handling and Logging: Implement robust error handling, logging, and monitoring for your API integrations to quickly identify and resolve issues.
• Rate Limit Management: Understand and implement strategies to adhere to Flipkart's API rate limits to prevent your application from being throttled.

Troubleshooting the first call

Encountering issues during your initial API calls is common. Here are some troubleshooting steps:

• Check Credentials: Double-check your API Key and Secret for typos. Ensure they are copied exactly as provided by Flipkart.
• Authentication Flow: Verify that you are following the correct authentication flow (e.g., proper grant type, correct headers for token request). Refer to Flipkart's specific authentication guide.
• Endpoint URLs: Confirm that you are using the correct base URLs and specific endpoint paths for both authentication and subsequent API calls. Environments (sandbox vs. production) often have different URLs.
• HTTP Status Codes: Pay close attention to the HTTP status codes returned in the API response.
• 400 Bad Request: Often indicates malformed request body or missing required parameters.
• 401 Unauthorized: Incorrect or missing Authorization header, expired token, or invalid credentials.
• 403 Forbidden: Your API key does not have the necessary permissions for the requested action, or your account is restricted.
• 404 Not Found: Incorrect endpoint URL.
• 429 Too Many Requests: You've hit a rate limit. Implement back-off strategies.
• 5xx Server Error: An issue on Flipkart's side. If persistent, contact support.
• Request Headers: Ensure all required headers (e.g., Content-Type, Authorization) are correctly set.
• JSON Payload: If sending a JSON payload, validate its structure and ensure it matches the API's expected schema.
• Network Connectivity: Verify that your development environment has unrestricted outbound access to Flipkart's API domains.
• Flipkart Seller Support: If you've exhausted self-troubleshooting, gather all relevant request/response logs, error messages, and API documentation references, then contact Flipkart Seller Support with comprehensive details.