> ## Documentation Index
> Fetch the complete documentation index at: https://edgeful.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# historic data screener

> returns the most recent screener data for one or more tickers from the last completed trading session. use this to fetch a point-in-time snapshot without opening a persistent connection. for live updates, use the screener pubsub stream instead.



## OpenAPI

````yaml /openapi-public.json get /historic_data_screener
openapi: 3.1.0
info:
  title: Edgeful API
  description: >-
    Public API reference for Edgeful market analysis calculations. The bearer
    token is your Edgeful API key: paste the key itself in the docs playground.
    Report responses include row-level output in `detailed` only when your plan
    includes row-level detail.
  version: 1.0.0
servers:
  - url: https://api.edgeful.com
    description: Production
security:
  - BearerAuth: []
tags:
  - name: reports
  - name: live data
paths:
  /historic_data_screener:
    get:
      tags:
        - live data
      summary: historic data screener
      description: >-
        returns the most recent screener data for one or more tickers from the
        last completed trading session. use this to fetch a point-in-time
        snapshot without opening a persistent connection. for live updates, use
        the screener pubsub stream instead.
      operationId: get_screener_data_historic_data_screener_get
      parameters:
        - name: market_type
          in: query
          required: true
          schema:
            type: string
            description: >-
              type of market to fetch data for. use `all` to fetch stocks and
              futures together.
            enum:
              - all
              - stock
              - futures
            title: Market Type
          description: >-
            type of market to fetch data for. use `all` to fetch stocks and
            futures together.
        - name: tickers
          in: query
          required: true
          schema:
            type: string
            description: >-
              comma-separated list of ticker symbols to retrieve (e.g.,
              `ES,NQ,CL`).
            title: Tickers
          description: >-
            comma-separated list of ticker symbols to retrieve (e.g.,
            `ES,NQ,CL`).
        - name: session_name
          in: query
          required: false
          schema:
            type: string
            description: trading session to fetch data for; one of `NY`, `LONDON`, `ASIA`.
            enum:
              - NY
              - LONDON
              - ASIA
            default: NY
            title: Session Name
          description: trading session to fetch data for; one of `NY`, `LONDON`, `ASIA`.
      responses:
        '200':
          description: Successful Response
          content:
            application/json:
              schema:
                type: object
                properties:
                  historic_data:
                    type: object
                    description: >-
                      Most recent historical screener snapshot keyed by ticker
                      symbol.
                    additionalProperties: true
              examples:
                pro_or_all_access:
                  summary: Historical screener snapshot
                  value:
                    historic_data:
                      ES:
                        opening_stats_standard:
                          current_price: 5275.25
                          historical_probability: 0.58
        '403':
          description: Valid API key, but the current plan does not include live data.
          content:
            application/json:
              examples:
                live_data_not_allowed:
                  summary: Live data not included on Essential
                  value:
                    detail:
                      detail: >-
                        Live data is not available on your current plan. Please
                        upgrade to the Pro or All Access plan to gain access.
                      code: live_data_not_allowed
        '422':
          description: Validation Error
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/HTTPValidationError'
      security:
        - BearerAuth: []
      x-codeSamples:
        - lang: curl
          label: cURL
          source: |-
            curl --request GET \
              --url 'https://api.edgeful.com/historic_data_screener?market_type=<market_type>&tickers=<tickers>' \
              --header 'Authorization: Bearer <api-key>'
        - lang: python
          label: Python
          source: >-
            import requests


            url =
            "https://api.edgeful.com/historic_data_screener?market_type=<market_type>&tickers=<tickers>"

            headers = {"Authorization": "Bearer <api-key>"}


            response = requests.get(url, headers=headers)

            print(response.json())
        - lang: javascript
          label: JavaScript
          source: >-
            const url =
            "https://api.edgeful.com/historic_data_screener?market_type=<market_type>&tickers=<tickers>";

            const options = {
              method: "GET",
              headers: { Authorization: "Bearer <api-key>" },
            };


            const response = await fetch(url, options);

            const data = await response.json();

            console.log(data);
        - lang: php
          label: PHP
          source: >-
            <?php

            $ch =
            curl_init("https://api.edgeful.com/historic_data_screener?market_type=<market_type>&tickers=<tickers>");

            curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "GET");

            curl_setopt($ch, CURLOPT_HTTPHEADER, ["Authorization: Bearer
            <api-key>"]);

            curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

            $response = curl_exec($ch);

            curl_close($ch);

            echo $response;
        - lang: go
          label: Go
          source: |-
            package main

            import (
                "fmt"
                "io"
                "net/http"
            )

            func main() {
                req, _ := http.NewRequest("GET", "https://api.edgeful.com/historic_data_screener?market_type=<market_type>&tickers=<tickers>", nil)
                req.Header.Set("Authorization", "Bearer <api-key>")
                resp, _ := http.DefaultClient.Do(req)
                defer resp.Body.Close()
                body, _ := io.ReadAll(resp.Body)
                fmt.Println(string(body))
            }
        - lang: java
          label: Java
          source: >-
            import java.net.URI;

            import java.net.http.HttpClient;

            import java.net.http.HttpRequest;

            import java.net.http.HttpResponse;


            HttpClient client = HttpClient.newHttpClient();

            HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://api.edgeful.com/historic_data_screener?market_type=<market_type>&tickers=<tickers>"))
                .header("Authorization", "Bearer <api-key>")
                .method("GET", HttpRequest.BodyPublishers.noBody())
                .build();
            HttpResponse<String> response = client.send(request,
            HttpResponse.BodyHandlers.ofString());

            System.out.println(response.body());
        - lang: ruby
          label: Ruby
          source: >-
            require "net/http"

            require "uri"


            uri =
            URI("https://api.edgeful.com/historic_data_screener?market_type=<market_type>&tickers=<tickers>")

            request = Net::HTTP::Get.new(uri)

            request["Authorization"] = "Bearer <api-key>"


            response = Net::HTTP.start(uri.hostname, uri.port, use_ssl:
            uri.scheme == "https") do |http|
              http.request(request)
            end

            puts response.body
components:
  schemas:
    HTTPValidationError:
      properties:
        detail:
          items:
            $ref: '#/components/schemas/ValidationError'
          type: array
          title: Detail
      type: object
      title: HTTPValidationError
    ValidationError:
      properties:
        loc:
          items:
            anyOf:
              - type: string
              - type: integer
          type: array
          title: Location
        msg:
          type: string
          title: Message
        type:
          type: string
          title: Error Type
        input:
          title: Input
        ctx:
          type: object
          title: Context
      type: object
      required:
        - loc
        - msg
        - type
      title: ValidationError
  securitySchemes:
    BearerAuth:
      type: http
      scheme: bearer
      bearerFormat: API Key
      description: >-
        Use your Edgeful API key as the bearer token. In the API Reference
        authorization drawer, paste only the key (for example,
        `ef_live_<random>`).

````