MarketAux Getting Started: API Key & First Request (2026)

Getting started overview

Integrating with the MarketAux API allows developers to access real-time and historical financial news data. The initial setup process is designed to be straightforward, typically involving account creation, API key retrieval, and the execution of a test request to confirm connectivity and authentication. MarketAux utilizes a RESTful architecture, delivering data in JSON format, which is a common standard for web APIs due to its human-readability and ease of parsing across various programming languages (W3C JSON specification).

MarketAux provides both a free tier for initial exploration and paid plans for higher usage, detailed on their MarketAux pricing page. SDKs are available for several popular languages, including Python, Node.js, and PHP, to streamline the integration process. This guide focuses on the fundamental steps to get a basic connection working.

Here’s a quick-reference table outlining the key steps:

Create an account and get keys

To begin using the MarketAux API, you must first create an account on their platform. This is a prerequisite for obtaining the necessary credentials to authenticate your API requests.

1. Navigate to the MarketAux homepage: Open your web browser and go to marketaux.com.
2. Sign up: Look for a "Sign Up" or "Get API Key" button, typically prominent on the homepage. Follow the prompts to register for a new account. This usually involves providing an email address, creating a password, and agreeing to the terms of service. MarketAux offers a Free Plan with 100 requests per day, which is suitable for initial testing and development.
3. Verify your email (if required): Some registration processes include an email verification step. Check your inbox for a confirmation email and click the verification link to activate your account.
4. Access your dashboard: Once logged in, you will be directed to your MarketAux user dashboard. This dashboard serves as the central hub for managing your account, monitoring usage, and accessing your API key.
5. Locate your API key: Within the dashboard, there will be a section dedicated to your API key. This key is a unique string of characters that authenticates your requests to the MarketAux API. It is crucial to keep this key confidential to prevent unauthorized access to your account and usage limits. Copy this key, as you will need it for every API call. The MarketAux documentation provides further details on API key management.

Your first request

After acquiring your API key, you can make your first request to the MarketAux API. This example will demonstrate how to fetch the latest financial news using the /news/all endpoint. We will use curl for a direct command-line example, which illustrates the underlying HTTP request structure. SDKs offer an abstraction layer for these requests.

API Endpoint

GET https://api.marketaux.com/v1/news/all?api_token=YOUR_API_TOKEN&filter_entities=true

Replace YOUR_API_TOKEN with the actual API key you obtained from your MarketAux dashboard. The filter_entities=true parameter is optional but useful for filtering out news without specific entities.

Using cURL (Command Line)

curl is a command-line tool for making HTTP requests and is universally available on most operating systems. This is often the quickest way to test an API endpoint without writing code.

curl -X GET "https://api.marketaux.com/v1/news/all?api_token=YOUR_API_TOKEN&filter_entities=true"

Execute this command in your terminal, replacing YOUR_API_TOKEN. You should receive a JSON object containing an array of financial news articles.

Using Python (with requests library)

Python is a popular language for scripting and web development, and its requests library simplifies HTTP interactions. The MarketAux documentation provides Python SDK examples.

import requests
import json

api_token = "YOUR_API_TOKEN"  # Replace with your actual API token
base_url = "https://api.marketaux.com/v1/news/all"

params = {
    "api_token": api_token,
    "filter_entities": True
}

try:
    response = requests.get(base_url, params=params)
    response.raise_for_status()  # Raise an exception for HTTP errors (4xx or 5xx)
    data = response.json()
    print(json.dumps(data, indent=2))

except requests.exceptions.HTTPError as http_err:
    print(f"HTTP error occurred: {http_err}")
    print(f"Response body: {response.text}")
except requests.exceptions.ConnectionError as conn_err:
    print(f"Connection error occurred: {conn_err}")
except requests.exceptions.Timeout as timeout_err:
    print(f"Timeout error occurred: {timeout_err}")
except requests.exceptions.RequestException as req_err:
    print(f"An unexpected error occurred: {req_err}")

Make sure you have the requests library installed (pip install requests). This code snippet sends a GET request and prints the pretty-formatted JSON response to the console. The error handling provides basic insights into potential issues.

Expected JSON Response Structure

A successful response will typically return a JSON object with a data array, each element representing a news article:

{
  "meta": {
    "limit": 100,
    "has_more": true,
    "returned": 100
  },
  "data": [
    {
      "uuid": "...",
      "title": "Example News Headline",
      "description": "This is a brief description of the news article.",
      "keywords": "stock, market, finance",
      "snippet": "A short excerpt from the article content.",
      "url": "https://example.com/news/article-link",
      "image_url": "https://example.com/image.jpg",
      "language": "en",
      "published_at": "2023-10-27T10:00:00.000000Z",
      "source": "Example News Source",
      "relevance_score": 0.95,
      "sentiment": "neutral",
      "entities": [
        {
          "symbol": "AAPL",
          "name": "Apple Inc.",
          "exchange": "NASDAQ",
          "exchange_long": "NASDAQ Stock Exchange",
          "asset_type": "Equity",
          "sentiment": "neutral",
          "score": 0.1
        }
      ]
    }
    // ... more news articles
  ]
}

Common next steps

Once you have successfully made your first API call to MarketAux, several common next steps can enhance your integration and leverage the API's full capabilities:

• Explore other endpoints: The MarketAux API offers various endpoints beyond /news/all, such as filtering by specific symbols (e.g., /news/all?symbols=GOOG), categories, or sentiment. Consult the MarketAux API reference for a comprehensive list and examples.
• Implement pagination: For retrieving large datasets, learn how to use the limit and offset parameters to paginate your results efficiently. This prevents overwhelming your application or hitting rate limits.
• Error handling: Implement robust error handling in your application to gracefully manage various API responses, including rate limits (HTTP 429), authentication failures (HTTP 401), or invalid requests (HTTP 400). The Twilio API error handling guide offers general best practices applicable to RESTful APIs.
• Utilize SDKs: If you are working with Python, PHP, Node.js, Go, or Ruby, consider using the official MarketAux SDKs. These libraries abstract away the complexities of HTTP requests, authentication, and JSON parsing, allowing you to focus on application logic.
• Monitor API usage: Regularly check your API usage statistics in the MarketAux dashboard to ensure you stay within your plan's limits and anticipate when an upgrade might be necessary.
• Advanced filtering and searching: Experiment with parameters like search, language, start_date, and end_date to refine your news queries and retrieve more specific information relevant to your application's needs.
• Integrate sentiment analysis: MarketAux provides sentiment scores for articles and entities. Incorporate this data into your application for features like market sentiment tracking or anomaly detection.

Troubleshooting the first call

Encountering issues during your first API call is common. Here are some typical problems and their solutions:

• 401 Unauthorized or authentication errors:
  • Incorrect API key: Double-check that you have copied your API key correctly from the MarketAux dashboard. Ensure there are no leading or trailing spaces.
  • Missing API key: Verify that the api_token parameter is present in your request URL.
  • Expired or revoked key: Although less common for a first call, ensure your API key is active. Check your MarketAux dashboard for its status.
• 400 Bad Request:
  • Invalid parameters: Review the MarketAux documentation for the specific endpoint you are calling. Ensure all required parameters are present and correctly formatted (e.g., dates in ISO 8601 format).
  • Incorrect endpoint: Confirm that the URL you are requesting matches an official MarketAux API endpoint.
• 429 Too Many Requests:
  • Rate limit exceeded: This indicates you've sent too many requests within a short period. Wait a few moments and try again. For continuous integration, implement exponential backoff in your code.
  • Free tier limits: If you are on the free plan, you are limited to 100 requests per day. Monitor your usage in the MarketAux dashboard.
• Network connection issues:
  • No internet connection: Verify your device has an active internet connection.
  • Firewall or proxy: Corporate firewalls or proxies can sometimes block outgoing API requests. Consult your network administrator if you suspect this is the case.
• Empty data array in response:
  • No matching news: Your filtering parameters (e.g., symbols, categories, dates) might be too restrictive or no news matching those criteria is currently available. Try broadening your search or removing some filters.
  • Recent data only: If you're requesting historical data and your plan doesn't support it, you might get an empty response. Check your plan details.
• SDK-specific errors: If you are using an SDK, consult the specific SDK's documentation for error codes and handling. Often, these errors wrap the underlying HTTP errors.