Astera Data Stack
Version 8
Version 8
  • Welcome to Astera Data Stack Documentation
  • Release Notes
    • Astera 8.0 - What's New, What's Fixed, and What's Improved
    • Astera 8.0 - Known Issues
    • Astera 8.1 - Release Notes
    • Astera 8.2 Release Notes
    • Astera 8.3 Release Notes
    • Astera 8.4 Release Notes
    • Astera 8.5 Release Notes
  • Getting Started
    • Astera 8 - Important Considerations
    • Astera 8 - System Requirements
    • Configuring the Server
    • Connecting to a Different Astera Server from the Lean Client
    • Connecting to an Astera Server using Lean Client
    • How to Build a Cluster Database and Create a Repository
    • How to Login from Lean Client
    • Setting up a Server Certificate (.pfx) File in a New Environment
    • Installing Client and Server Applications
    • Licensing Model in Astera 8
    • Migrating from Astera 7.x to Astera 8
    • UI Walkthrough - Astera 8.0
    • User Roles and Access Control
  • Dataflows
    • Sources
      • Data Providers and File Formats Supported in Astera
      • Setting Up Sources
      • COBOL File Source
      • Database Table Source
      • Data Model Query Source
      • Delimited File Source
      • Email Source
      • Excel Workbook Source
      • File Systems Item Source
      • Fixed Length File Source
      • PDF Form Source
      • Report Source
      • SQL Query Source
      • XML/JSON File Source
    • Transformations
      • Introducing Transformations
      • Aggregate Transformation
      • Constant Value Transformation
      • Data Cleanse Transformation
      • Denormalize Transformation
      • Distinct Transformation
      • Database Lookup Transformation
      • Expression Transformation
      • File Lookup Transformation
      • Filter Transformation
      • Join Transformation
      • List Lookup Transformation
      • Merge Transformation
      • Normalize Transformation
      • Passthru Transformation
      • Reconcile Transformation
      • Route Transformation
      • Sequence Generator Transformation
      • Sort Transformation
      • Sources as Transformations
      • Subflow Transformation
      • SQL Statement Lookup Transformation
      • Switch Transformation
      • Tree Join Transformation
      • Tree Transform
      • Union Transformation
    • Destinations
      • Setting Up Destinations
      • Database Table Destination
      • Delimited File Destination
      • Excel Workbook Destination
      • Fixed Length File Destination
      • SQL Statement Destination
      • XML/JSON File Destination
    • Data Logging and Profiling
      • Creating Data Profile
      • Creating Field Profile
      • Data Quality Mode
      • Record Level Log
      • Using Data Quality Rules in Astera
    • Database Write Strategies
      • Database Diff Processor
      • Data Driven Write Strategy
      • Dimension Loader - Database Write
      • Source Diff Processor
    • Text Processors
      • Delimited Parser
      • Delimited Serializer
      • Fixed Length Parser
      • Fixed Length Serializer
      • Language Parser
      • XML JSON Parser
      • XML JSON Serializer
    • Data Warehouse
      • Fact Table Loader
      • Dimension Table Loader
  • WORKFLOWS
    • What Are Workflows?
    • Using the Workflow Designer
    • Creating Workflows in Astera
    • Decision Task
    • EDI Acknowledgement Task
    • File System Task
    • File Transfer Task
    • OR Task
    • Run Dataflow Task
    • Run Program Task
    • Run SQL File Task
    • Run SQL Script Task
    • Run Workflow Task
    • Send Mail Task
    • Workflows with a Dynamic Destination Path
    • Customizing Workflows with Parameters
    • GPG-Integrated File Decryption in Astera
  • Subflows
    • Using Subflows in Astera
  • Functions
    • Introducing Function Transformations
    • Custom Functions
    • Logical
      • Coalesce (Any value1, Any value2)
      • IsNotNull (AnyValue)
      • IsRealNumber (AnyValue)
      • IsValidSqlDate (Date)
      • IsDate (AnyValue)
      • If (Boolean)
      • If (DateTime)
      • If (Double)
      • Exists
      • If (Int64)
      • If (String)
      • IsDate (str, strformat)
      • IsInteger (AnyValue)
      • IsNullOrWhitespace (StringValue)
      • IsNullorEmpty (StringValue)
      • IsNull (AnyValue)
      • IsNumeric (AnyValue)
    • Conversion
      • GetDateComponents (DateWithOffset)
      • ParseDate (Formats, Str)
      • GetDateComponents (Date)
      • HexToInteger (Any Value)
      • ToInteger (Any value)
      • ToDecimal (Any value)
      • ToReal (Any value)
      • ToDate (String dateStr)
      • TryParseDate (String, UnknownDate)
      • ToString (Any value)
      • ToString (DateValue)
      • ToString (Any data, String format)
    • Math
      • Abs (Double)
      • Abs (Decimal)
      • Ceiling (Real)
      • Ceiling(Decimal)
      • Floor (Decimal)
      • Floor (Real)
      • Max (Decimal)
      • Max (Date)
      • Min (Decimal)
      • Min (Date)
      • Max (Real)
      • Max (Integer)
      • Min (Real)
      • Pow (BaseExponent)
      • Min (Integer)
      • RandomReal (Int)
      • Round (Real)
      • Round (Real Integer)
      • Round (Decimal Integer)
      • Round (Decimal)
    • Financial
      • DDB
      • FV
      • IPmt
      • IPmt (FV)
      • Pmt
      • Pmt (FV)
      • PPmt
      • PPmt (FV)
      • PV (FV)
      • Rate
      • Rate (FV)
      • SLN
      • SYD
    • String
      • Center (String)
      • Chr (IntAscii)
      • Asc (String)
      • AddCDATAEnvelope
      • Concatenate (String)
      • ContainsAnyChar (String)
      • Contains (String)
      • Compact (String)
      • Find (Int64)
      • EndsWith (String)
      • FindIntStart (Int32)
      • Extract (String)
      • GetFindCount (Int64)
      • FindLast (Int64)
      • GetDigits (String)
      • GetLineFeed
      • Insert (String)
      • IsAlpha
      • GetToken
      • IndexOf
      • IsBlank
      • IsLower
      • IsUpper
      • IsSubstringOf
      • Length (String)
      • LeftOf (String)
      • Left (String)
      • IsValidName
      • Mid (String)
      • PadLeft
      • Mid (String Chars)
      • LSplit (String)
      • PadRight
      • ReplaceAllSpecialCharsWithSpace
      • RemoveChars (String str, StringCharsToRemove)
      • ReplaceLast
      • RightAlign
      • Reverse
      • Right (String)
      • RSplit (String)
      • SplitStringMultipleRecords
      • SplitStringMultipleRecords (2 Separators)
      • SplitString (3 separators)
      • SplitString
      • SplitStringMultipleRecords (3 Separators)
      • Trim
      • SubString (NoOfChars)
      • StripHtml
      • Trim (Start)
      • TrimExtraMiddleSpace
      • TrimEnd
      • PascalCaseWithSpace (String str)
      • Trim (String str)
      • ToLower(String str)
      • ToProper(String str)
      • ToUpper (String str)
      • Substring (String str, Integer startAt)
      • StartsWith (String str, String value)
      • RemoveAt (String str, Integer startAt, Integer noofChars)
      • Proper (String str)
      • Repeat (String str, Integer count)
      • ReplaceAll (String str, String lookFor, String replaceWith)
      • ReplaceFirst (String str, String lookFor, String replaceWith)
      • RightOf (String str, String lookFor)
      • RemoveChars (String str, String charsToRemove)
      • SplitString (String str, String separator1, String separator2)
    • Date Time
      • AddMinutes (DateTime)
      • AddDays (DateTimeOffset)
      • AddDays (DateTime)
      • AddHours (DateTime)
      • AddSeconds (DateTime)
      • AddMonths (DateTime)
      • AddMonths (DateTimeOffset)
      • AddMinutes (DateTimeOffset)
      • AddSeconds (DateTimeOffset)
      • AddYears (DateTimeOffset)
      • AddYears (DateTime)
      • Age (DateTime)
      • Age (DateTimeOffset)
      • CharToSeconds (Str)
      • DateDifferenceDays (DateTimeOffset)
      • DateDifferenceDays (DateTime)
      • DateDifferenceHours (DateTimeOffset)
      • DateDifferenceHours (DateTime)
      • DateDifferenceMonths (DateTimeOffset)
      • DateDifferenceMonths (DateTime)
      • DatePart (DateTimeOffset)
      • DatePart (DateTime)
      • DateDifferenceYears (DateTimeOffset)
      • DateDifferenceYears (DateTime)
      • Month (DateTime)
      • Month (DateTimeOffset)
      • Now
      • Quarter (DateTime)
      • Quarter (DateTimeOffset)
      • Second (DateTime)
      • Second (DateTimeOffset)
      • SecondsToChar (String)
      • TimeToInteger (DateTime)
      • TimeToInteger (DateTimeOffset)
      • ToDate Date (DateTime)
      • ToDate DateTime (DateTime)
      • ToDateString (DateTime)
      • ToDateTimeOffset-Date (DateTimeOffset)
      • ToDate DateTime (DateTimeOffset)
      • ToDateString (DateTimeOffset)
      • Today
      • ToLocal (DateTime)
      • ToJulianDate (DateTime)
      • ToJulianDayNumber (DateTime)
      • ToTicks (Date dateTime)
      • ToTicks (DateTimeWithOffset dateTime)
      • ToUnixEpoc (Date dateTime)
      • ToUtc (Date dateTime)
      • UnixTimeStampToDateTime (Real unixTimeStamp)
      • UtcNow ()
      • Week (Date dateTime)
      • Week (DateTimeWithOffset dateTime)
      • Year (Date dateTime)
      • Year (DateTimeWithOffset dateTime)
      • DateToJulian (Date dateTime, Integer length)
      • DateTimeOffsetUtcNow ()
      • DateTimeOffsetNow ()
      • Day (DateTimeWithOffset dateTime)
      • Day (Date dateTime)
      • DayOfWeekStr (DateTimeWithOffset dateTime)
      • DayOfWeek (DateTimeWithOffset dateTime)
      • DayOfWeek (Date dateTime)
      • DateToJulian (DateTimeWithOffset dateTime, Integer length)
      • DayOfWeekStr (Date dateTime)
      • FromJulianDate (Real julianDate)
      • DayOfYear (Date dateTime)
      • DaysInMonth(Integer year, Integer month)
      • DayOfYear (DateTimeWithOffset dateTime)
      • FromUnixEpoc
      • FromJulianDayNumber (Integer julianDayNumber)
      • FromTicksUtc(Integer ticks)
      • FromTicksLocal(Integer ticks)
      • Hour (Date dateTime)
      • Hour (DateTimeWithOffset dateTime)
      • Minute (Date dateTime)
      • JulianToDate (String julianDate)
      • Minute (DateTimeWithOffset dateTime)
      • DateToIntegerYYYYMMDD (DateTimeWithOffset dateTime)
      • DateToIntegerYYYYMMDD (Date dateTime)
    • Files
      • AppendTextToFile (String filePath, String text)
      • CopyFile (String sourceFilePath, String destFilePath, Boolean overWrite)
      • CreateDateTime (String filePath)
      • DeleteFile (String filePath)
      • DirectoryExists (String filePath)
      • FileExists (String filePath)
      • FileLength (String filePath)
      • FileLineCount (String filePath)
      • GetDirectory (String filePath)
      • GetEDIFileMetaData (String filePath)
      • GetExcelWorksheets (String excelFilePath)
      • GetFileExtension (String filePath)
      • GetFileInfo (String filePath)
      • GetFileName (String filePath)
      • GetFileNameWithoutExtension (String filePath)
      • LastUpdateDateTime (String filePath)
      • MoveFile (String filePath, String newDirectory)
      • ReadFileBytes (String filePath)
      • ReadFileFirstLine (String filePath)
      • ReadFileText (String filePath)
      • ReadFileText (String filePath, String codePage)
      • WriteBytesToFile (String filePath, ByteArray bytes)
      • WriteTextToFile (String filePath, String text)
    • Date Time With Offset
      • ToDateTimeOffsetFromDateTime (dateTime String)
      • ToUtc (DateTimeWithOffset)
      • ToDateTimeOffsetFromDateTime
      • ToDateTimeOffset (String dateTimeOffsetStr)
      • ToDateTimeFromDateTimeOffset
    • GUID
      • NewGuid
    • Encoding
      • ToBytes
      • FromBytes
      • UrlEncode
      • UrlDecode
    • Regular Expressions
      • ReplaceRegEx
      • ReplaceRegEx (Integer StartAt)
    • TimeSpan
      • Minutes
      • Hours
      • Days
      • Milliseconds
    • Matching
      • Soundex
      • DoubleMetaphone
      • RefinedSoundex
  • Report Model
    • User Guide
      • Report Model Tutorial
    • Report Model Interface
      • Field Properties Panel
      • Region Properties Panel
      • Report Browser
      • Report Options
    • Use Cases
      • Applying Pattern to Line
      • Auto Creating Data Regions and Fields
      • Auto-Parsing
      • Creating Multi-Column Data Regions
      • Floating Patterns and Floating Fields
      • How To Work With PDF Scaling Factor in a Report Model
      • Line Count
      • Pattern Count
      • Pattern is a Regular Expression
    • Exporting Options
      • Exporting a Report Model
      • Exporting Report Model to a Dataflow
    • Miscellaneous
      • Importing Monarch Models
      • Microsoft Word and Rich Text Format Support
      • Working With Problematic PDF Files
  • API Flows
    • API Consumption
      • Consume
        • REST API Browser
        • Making HTTP Requests Through REST API Browser
        • Using REST Client Outside of the Scope of the Project
      • Authorize
        • Authorizing ActiveCampaign API in Astera
        • Authorizing Astera Server APIs
        • Authorizing Avaza APIs in Astera
        • Authorizing Facebook APIs in Astera
        • Authorizing QuickBooks API in Astera
        • Authorizing Square API in Astera
        • Open APIs - Configuration Details
  • Project Management
    • Project Management
      • Astera's Project Explorer
      • Connecting to Source Control
      • Deployment
      • Server Monitoring and Job Management
    • Job Scheduling
      • Scheduling Jobs on the Server
      • Job Monitor
  • Use Cases
    • End-to-End Use Cases
      • Data Integration
        • Using Astera to Create and Orchestrate an ETL Process for Partner Onboarding
      • Data Warehousing
        • Building a Data Warehouse - A Step-By-Step Approach
      • Data Extraction
        • Reusing The Extraction Template for Similar Layout Files
  • Connectors
    • Connecting to Amazon Aurora Database
    • Connecting to Amazon RDS Databases
    • Connecting to Amazon Redshift Database
    • Connecting to Cloud Storage
    • Connecting to Google Cloud SQL in Astera
    • Connecting to MariaDB Database
    • Connecting to Microsoft Azure Databases
    • Connecting to MySQL Database
    • Connecting to Netezza Database
    • Connecting to Oracle Database
    • Connecting to PostgreSQL in Astera
    • Connecting to Salesforce Database
    • Connecting to Salesforce - Legacy Database
    • Connecting to SAP HANA Database
    • Connecting to Snowflake Database
    • Connecting to Vertica Database
    • Setting Up IBM DB2 iSeries Connectivity in Astera
  • Miscellaneous
    • Cloud Deployment
      • Deploying Astera on Amazon Web Services
      • Deploying Astera on Microsoft Azure Cloud
      • Deploying Astera on Oracle Cloud
    • Context Information
    • Pushdown Mode
    • Role Based Access Control in Astera
    • Safe Mode
    • Server Command Line Utility
    • SmartMatch Feature
    • Synonym Dictionary File
    • Updating Your License in Astera
    • Using Dynamic Layout/Template Mapping in Astera
    • Using Output Variables in Astera
    • Using the Data Source Browser in Astera
  • Best Practices
    • Astera Best Practices - Dataflows
    • Overview of Cardinality in Data Modeling
    • Cardinality Errors FAQs
Powered by GitBook

© Copyright 2025, Astera Software

On this page
  • Making a GET Request
  • REST Request
  • Pagination
  • Offset
  • Cursor
  • Next URL
  • Page Number
  • Making a POST Request
  • Making a DELETE Request
  • Making a PATCH Request
  • Working with APIs That Require Authentication
  1. API Flows
  2. API Consumption
  3. Consume

Making HTTP Requests Through REST API Browser

PreviousREST API BrowserNextUsing REST Client Outside of the Scope of the Project

Last updated 9 months ago

In this document, we will see how we can make HTTP requests through REST API Browser in Astera.

Making a GET Request

To make a GET request, drag and drop the relevant GET request object from the REST API Browser onto the designer window and pass your required PetId into it.

In this scenario, we want to get the info for pet with the PetId ‘3’. For this, we will select the GET request ‘Find pet by ID’ and pass the relevant PetId using a ConstantValue object.

To explore the REST Client object for this method, right-click on its header and select Properties.

This will open the REST Client screen where the connection info of your API is defined.

  • Shared Connection – shows the name of your REST Connection. You can select any shared REST API Connection you want to use from the drop-down list. The connections for all the APIs that have been imported in the project will be shown here.

REST Request

  • HTTP Method – shows the HTTP method of your request

  • Resource – shows what information you want to get from a specific API. It is a part of the UrI of request sent.

  • Content Type – shows the type of your content

All the above information is configured according to the request method that you have selected.

Click Next to proceed to the Parameters screen.

Here, you will see the following options:

  • Name - it contains the name of the parameter

  • Parameter Location - it tells which parameter is being used to make the call. The following three parameters are supported by Astera:

    • URL: This is a required parameter.

    • Query: This parameter may or may not be optional and can work as a filter while processing records.

    • Header: This parameter is generally used for authentication purpose.

Click Next to proceed to the Output Layout screen where you can build the Response Layout of your API. There are two ways in which you can generate the output layout:

  1. The first one is by providing sample text by clicking on Generate Layout by providing Sample Text option.

  2. The other way to do that is by running a request by clicking the Generate Layout by running Request option.

Click Next to proceed to the Pagination Options screen.

Pagination

Pagination refers to managing the traffic of records coming from a source. It divides the records into discrete number of pages so that they are comprehensible for a user. Pagination is not supportedby all APIs. For those that do, Astera offers four types of pagination.

Offset

It requires two parameters: a limit and an offset value to be specified by the user. A limit specifies the number of records that you want to specify in one page and an offset simply tells the number of records to be skipped before selecting records.

  • Initial Offset – the record from which you want to start your pagination

  • Number of Pages – the number of pages which you want to be processed

  • Limit - number of records on one page

  • Offset Parameter - here, you specify the offset parameter of the API that you are working with as specified on the Parameters screen

  • Limit Parameter - here, you specify the limit parameter of the API that you are working with as specified on the Parameters screen

Cursor

This type of pagination generates a token for the next page of records. You can set a limit to the number of pages you want to process.

  • Cursor Field – here, the field you want to attach your cursor with is specified.

  • Number of Pages – here, the number of pages you want to see in your output are specified or you can simply check the option of Read Till End if you want to process all the records without any limit.

  • Cursor Parameter - here, you specify the cursor parameter of the API that you are working with as specified on the Parameters screen.

Next URL

It is the same as Cursor pagination, except that it generates a URL for every next page instead of a token.

  • Next URL Field - here, the field you want to attach your URL with is specified.

  • Number of Pages - here, the number of pages you want to see in your output are specified or you can simply check the option of ‘Read Till End’ if you want to process all the records without any limit.

Page Number

In this type of pagination, you can specify the number of pages you would like to fetch in one go. It requires two parameters:

  • Start Page Number - the page number from where you want to start fetching your output or the lower limit

  • End Page Number - the page number where you want to end

  • Page Number Parameter - here, you specify the page number parameter of the API that you are working with as specified on the Parameters screen

Click Next to proceed to the the Service Options screen.

Here you can see the following service options:

  • Request Delay – the time (in milliseconds) to be delayed before sending a request

  • Retry Count – the number of retries to be made in case of a failed request

  • Retry Delay – the time (in milliseconds) to be delayed before making a request again

  • Ignore HTTP Status Codes checkbox is used to skip the error response for unsuccessful requests

  • Continue on Retry Failure - this option is used to retry building the connection if it fails

  • Use Parallelism - this option specifies if you want multiple requests to be run in parallel and the number of those requests can be specified in Degree of Parallelism option

  • Include Content as String - you can check this option if you want to include your content in the output preview

  • Include Response Headers - you can check this option if you want to include the response headers in you data preview

  • Include Raw Bytes - you can check this option if you want to include the raw data bytes in your data preview

Once you have specified these options, click OK.

Making a POST Request

Now, let’s try posting a pet to Petstore. Drag the Add a new pet to the store request from the REST API Browser panel and drop it on to the dataflow designer.

We will pass the required parameters to the POST request object using a Variables object.

Now, right-click on the REST API Client (addPet) object and select Preview Output.

You can see that the HTTPStatusCode is 200 which means that the REST API has successfully carried out the action requested by client. Let’s verify it by making a GET request for the same PetId which we had posted earlier.

You can see that a GET request for PetId 1 has returned us the same information which we had posted.

Making a DELETE Request

Now, let’s try making a DELETE request. For that, we will first make a GET request to see if that pet exists on the petstore or not and try to delete that. We will pass PetId 5 using a ConstantValue object.

Right-click on the REST Client (getPetById) object and select Preview Output.

It has fetched the details of the pet with PetId 5, and the status shows that the pet is available on Petstore.

To delete this pet record, we will drag and drop the Deletes a pet request from the REST API Browser panel on to dataflow designer.

Pass PetId 5 to the DELETE request object using a ConstantValue object.

Right-click on the REST Client object and select Preview Output. You can see that it has returned ‘HTTPStatusCode’ 200 which indicates a successful execution.

Let’s verify it by making a GET request again and check if pet with PetId 5 has been deleted.

Right-click on the REST API Client (getPetById) object and select Preview Output.

You can see that Astera has returned error 404 which means that there is no pet found with PetId 5 and the pet record has been successfully deleted from petstore API.

Making a PATCH Request

Let’s make a GET request to see what information is there in the user ID where we want to update something.

To make a GET request, drag and drop the ‘GetUser’ method from the REST API Browser onto the designer window.

Pass userID ‘89’ to the userId under the Parameters node in the ‘GetUser’ object using ConstantValue transformation.

Right-click on the header of REST Client (GetUser) object and select Preview Output.

Here is what the output looks like:

Now, drag and drop the ‘PatchUser’ method from the REST API Browser and drop it on to the designer window.

Pass userId ‘89’ and email ‘updatedemail@astera.com’ using a Variables resource object.

Right click on the PatchUser and select Preview Output.

You can see that the ‘HTTPStatusCode’ is 200 which means that the REST API has successfully carried out the PATCH request. Let’s verify it by making a GET request for the same userId in which we made the changes.

Right-click on the header of the ‘GetUser’ object and select Preview Output.

Working with APIs That Require Authentication

Let’s try making an API request that needs authentication. We’ll be making a GET request object using an Adafruit API.

  1. First, import the API by using the relevant import source. In this case, we will import using the JSON/YML URL import source.

You will see that all the APIs present on Adafruit’s URL have been populated in the REST API Browser.

  1. Now, you need to authenticate Adafruit’s APIs to use them in your dataflow. Without authentication, you will get an error. To authenticate an API, go to the Project Explorer and double click on the API’s .sact file under the Shared Connection node. In this case, we will double-click on Adafruit’s .sact file.

  1. Adafruit’s .sact file will open on the designer. Now, right click on shared action file’s header and select Properties.

This will open the REST Connection window where you can configure the settings to authenticate Adafruit’s API.

Authentication

Following authentication types are supported in Astera:

  1. No Authentication

  2. OAuth 2

  3. API Key

  4. Basic Authentication

  5. Bearer Token

No Authentication

With this security type, the user can send requests and receive responses without any kind of authentication from APIs.

O Auth 2

In the OAuth 2 authentication, you can select any of the four grant types:

  1. Implicit

  2. Authorization Code

  3. Password

  4. Client Credentials

Implicit

In this grant type, you only need to provide Authentication URL and Client ID to request token and authorize.

Authorization Code

In this grant type, you need to provide Authentication URL, Access Token URL, Client ID, and Client Secret to authorize.

Password

In this grant type, you need Access Token URL, Username, Password, Client ID and Client Secret in order to authorize.

Client Credentials

In this grant type, you need Access Token URL, Client ID, and Client Secret to authorize.

API Key

An API Key is a token that a client provides when it makes an API request. An API key is a secret that only the client and server know. They can be sent in the Query string or as a request Header.

It requires two parameters for authentication:

  1. Key

  2. Value

Basic Authentication

Basic Authentication is structured according to the HTTP protocol to provide a username and password when making a REST request. In basic HTTP authentication, a request contains a header field in the form of Authentication: Basic , where credentials are the Base64 encoding of ID and password joined by a single colon “:”.

It requires the following information:

  1. Username

  2. Password

Bearer Token

Bearer token or token authentication is an HTTP-based authentication. The token is a text string included in the request header. It is generated by the server in response to a login request.

To authorize Bearer token, you need:

  1. User Name

  2. Password

  3. Token URL

  1. Select the Security Type and specify the relevant details.

You can see that the Security Type has been specified as API Key which means that the Adafruit’s API uses API Key as its authentication method.

  1. Click OK. Now that the API has been authenticated, we can work with the API and make HTTP requests.

To make a GET request, drag and drop the Get feed by feed key object from the REST API Browser on to the dataflow designer.

It requires two parameters: username and feed_key. We will pass the values to these parameters either by using a source object via mapping it or by specifying the parameter value in the default value column in the properties of the getFeed object.

In this case, we have provided the username through a ConstantValue object. Now let’s specify the feed_key in the Default Value column in the properties of the getFeed object.

Right click on the REST Client object (getFeed) and select Properties. Go to the Parameters screen and specify the feed_key value in the Default Value column.

Click Next to proceed to the Output Layout screen. Here, you can see the Response Layout of your selected method.

Click Next to proceed to the the Service Options screen.

Now, right click on the REST Client (getFeed) object and select Preview Output.

You can see that Astera has returned the feed information by providing the required parameters.

This concludes making HTTP requests through REST API Browser in Astera.

As you can see, the request has been successfully carried out and the email address has been updated to .

updatedemail@astera.com