Skip to main content
100%

Building an API with ReadMe Build

✓ Published0🌍 Public
Aachalvs
Last edited Jul 4, 2018
Created on Jul 4, 2018

This example shows a text-based API endpoint that returns the daily status of FIFA World Cup 2018 matches, including scores, penalties, and match outcomes. It uses the `request` library to fetch match data from the `https://worldcup.sfg.io/matches/today` endpoint, and the `moment` library to format match times in GMT. The code constructs a human-readable schedule string for each game, handling completed, live, and upcoming statuses, and optionally sends the schedule via SMS using the `api` module from ReadMe Build. It outputs the schedule as plain text, or a message if no matches occur that day.

AI-generated description

Similar vizzes

Loading thumbnail…

creating an HTTP request inside our API

This example shows how to build an HTTP request inside an API to fetch today’s World Cup match data from the `worldcup.sfg.io` endpoint. The code uses the `request` library to make the call, `moment` for time handling, and the `api` module for configuration. It parses the JSON response, initializes an empty schedule array, and iterates over each match to log its details to the console, demonstrating a straightforward data retrieval and inspection workflow.

Aachalvs
78% match
Loading thumbnail…

our final API!

This example displays the daily schedule of FIFA World Cup 2018 matches, showing each game’s status (SOON, LIVE, or FINAL), the local time in GMT, and the scores for both teams, including penalty shootout results and the match outcome. It retrieves data from the worldcup.sfg.io API, processes the JSON response using JavaScript, and formats timestamps with the Moment.js library. The code uses the Request module for HTTP calls and the StdLib API to optionally send the schedule as a text message via a phone number.

Aachalvs
76% match
Loading thumbnail…

comments for our World Cup API!

This visualization displays the daily status of FIFA World Cup 2018 matches, including scores, winners, and scheduled local times for upcoming games. It uses a custom JavaScript API endpoint that takes an optional US phone number for schedule alerts and handles validation errors. The rendering relies on d3.forceSimulation for node positioning and d3.geoPath for geographic mapping, with Canvas getImageData for pixel-level interactions. The data source is a gist by achalvs, and the code demonstrates how API responses drive the visual representation of match outcomes and time-zone-aware scheduling.

Aachalvs
65% match
Loading thumbnail…

Gist 490c3c436c63c09d502d99c3de991fd3

This example demonstrates a phone-based notification workflow that sends a schedule message through the ReadMe Build API. The code checks whether an input contains a phone number, and if so, invokes the `api('text')` service to run a `send` operation with the recipient and message payload, logging any errors. It then reports success back to the ReadMe Build system via `service.success(schedule)`. The visualization highlights the conditional branching and asynchronous API interaction, though no charting library or graphical rendering is present in the provided snippet.

Aachalvs
64% match
Loading thumbnail…

Gist 634708b061502ecb288faed61b1b15d4

This example builds a data pipeline that fetches Fantasy Premier League player and fixture data, merges it with betting odds from an S3 bucket, and uploads the enriched results back to S3 as CSV files. The code uses the `requests` library to query the FPL API, `pandas` for data manipulation, and `boto3` to interact with AWS S3. It calculates a difficulty metric (`diff`) by comparing home and away win probabilities from the odds. The visualization would show how player value or form changes across gameweeks based on this aggregated data, though the gist itself focuses on data preparation rather than rendering.

CConorAspell
56% match
Loading thumbnail…

imports for fifa bot

This visualization shows the import dependencies for a FIFA-related bot, mapping how modules connect through required dependencies. The code uses `request` for HTTP calls, `moment` for date handling, and an API configuration from `api.config()`, though the rendering logic itself is not shown. The example likely relies on a force-directed layout to display these connections, given the use of `d3.forceSimulation` in similar dependency graphs, but the actual visualization code is not included in the snippet. The data source is a JavaScript module that exports a function taking `data` and `api` parameters, suggesting a custom integration with an external API for match or player data.

Aachalvs
55% match
Loading thumbnail…

Gist 9bf3c1df30c761a2f4056979099ea7cd

This example shows an automated Fantasy Premier League workflow that posts a user’s finalized team sheet for a given gameweek. It retrieves the full team JSON from an S3 bucket and submits it to the league’s API via a POST request. The code uses the `requests` library for HTTP communication, `json` for data handling, and custom utility functions from `fpl_utils` to fetch gameweek parameters and storage details. Error handling triggers an SNS notification to a specified topic if the API call fails. The visualization highlights the integration between cloud storage, Lambda execution, and external sports data endpoints.

CConorAspell
55% match
Loading thumbnail…

Gist 0b62984b5a27dcec2db3a4f234affd91

This example shows an automated pipeline that fetches English Premier League match odds from the Odds API and stores them as timestamped CSV files in Amazon S3. The code first pulls fixture deadlines from the Fantasy Premier League bootstrap API, then filters upcoming matches between the current and next deadline. It extracts William Hill’s home, draw, and away odds for each qualifying game, using the `requests` and `pandas` libraries to process the JSON responses into a DataFrame. Finally, the script writes the odds data to a CSV file named with the current date, demonstrating a serverless data ingestion workflow with `boto3` and AWS Lambda.

CConorAspell
54% match